Kapi ap l S e S hgal P T C p t u er. r S. c S ienc n e A n A k n leshw h ar ar Guj u arat C C h - 8

Size: px

Start display at page:

Download "Kapi ap l S e S hgal P T C p t u er. r S. c S ienc n e A n A k n leshw h ar ar Guj u arat C C h - 8"

Imogen Richardson
5 years ago
Views:

1 Chapter 8 Introduction C++ Memory Map Free Stores Declaration and Initialization of pointers Dynamic allocation operators Pointers and Arrays Pointers and Const Pointers and Function Pointer and Structures Object as function arguments Pointers and Object

2 Introduction of Pointers A pointer is a variable that holds a memory address, usually the location of another variable in memory. Three reasons for the pointers supports in C++ First, Pointers provides the means through which the memory location of a variable can be directly accessed. Second, Pointers supports C++ s dynamic allocation routines. Third, Pointers can improve the efficiency of certain routines. Warnings!!!!!!!!!!!! (Limitation) Un initialized or wild pointers can cause your system crash.

3 C++ Memory Map C++ creates four logically distinct regions of memory that are used for four distinct specific function. One region in the memory holds the compiled code of the program. Every instruction and every function of the program starts at a particular address. The next region is the memory area where the global variable of the program are stored. Global variable remain in the memory as long as program continues. Third region is known as stack, is used in great many things while your program execute. The stack is used for holding return address of the function calls. The Heap memory are is a region of free memory from which dynamic memory allocation function works.

4 Memory Map Global Variable 2. Stack 3 Heap 4 Program Code 1. Area used for function calls, return address, arguments and local variables. Area Used for dynamic allocation of memory

5 Dynamic and Static Allocation of Memory The Golden rule of computers states that, anything and every thing (data and instruction) that needs to be processed must be loaded into internal memory before its processing takes place. It means every data and instruction that is being executed must be allocated some are in the main memory. The Main memory is allocated in two ways. First is - Static Memory Allocation Second is Dynamic Memory Allocation.

6 Static Memory Allocation When an amount of memory to be allocated is known beforehand and the memory is allocated during compilation itself. It is referred as Static Memory Allocation. Ex--- int x; In this case computer knows that what the length of a int variable is, generally it is 2 bytes. So a chunk of 2 bytes internal memory will be allocated variable x during compilation itself. This is example of static memory allocation.

7 Dynamic Memory Allocation When the amount of memory to be allocated is not known beforehand as required during runtime itself, then the allocation of memory at run time is referred to a dynamic memory allocation. C++ offers two operators for dynamic memory allocation new and delete. The Operator new allocates the memory dynamically and return a pointer storing the memory address of the allocated memory. The operator delete de allocates the memory pointed by the given pointers. Free Store - Free Store is a pool of unallocated heap memory given to a program that is used by program for dynamic allocation during exection

8 Declaration & Initialization of Pointers Pointer variable are declared like other variable except for the addition of the unary * character. The general form of a pointer declaration is as follows type *var_name; Where type is any valid C++ data type and var-nameis the name of the pointer variable. Ex. int *iptr; char *name; float *i; Here all are pointer variable and can hold only address of concerned type; There are two special operator * and & are used with pointers. int i =25; // declares and initialize an int variable i; int *iptr; //declares the pointer variable iptr; iprt = &i; // Stores the memory address of I into iprt;

9 Working of & operator Address of i 1050 i 25 int i =25; int *iptr iptr 1050 iptr = &i; j 25 j = i & operator is used, when we want to access the address of any variables. We must put the & operator before the variable.

10 Working of * Operator &i i iptr j The second pointer operator, * does the reverse of &. The unary operator * return the value of of the variable located at the address following it.

11 Pointer Arithmetic Only two arithmetic operations addition and subtraction may be performed on pointers. When you add 1 to a pointer, you actually adding the size of whatever the pointer is pointing at. Each time a pointer is incremented by 1, it points to the memory location of the next element of the base type. Ex int *p; // Let currently pointed memory addess p++; // the next position p pointed at 1003 not for 1002, because size of int is 2 bytes. So it should increase by 2.; P+=3; // now p pointed at position ( =1009)

12 Dynamic Allocation Operators Dynamic allocation is the means by which a program can obtain memory during runtime. The Global and Local variables are allocated memory during compile-time. How ever you can not add any global or local variable during run-time. In such a case you would need to allocate memory during runtime, as and when needed. C++ defines two unary operators new and delete that perform the task of allocating and freeing memory at runtime. The new operator can be used to allocated memory. Ex.. pointer-variable = new data-type; Ex.. student *k; k = new student;

13 Continue. Once a pointer points to newly allocated memory data values can be stored there using the address operator (*). int *t; //declare an pointer to int variable; t = new int; // assing the memroy to *t variable *t=50; // assign the value to the memory of t; t 50 t 1054 Address of t 1051

14 Creating Dynamic Array The operator new can also allocate memory for user-defined types like structure, array and classes. To allocate memory for a one-dimensional array, new operator used as follows. pointer-variable = new data-type[size]; int *value = new int[10] ; // equivalent to - int value[10]; It will create an array value of 10 integer value. To allocate memory for two dimensional array new operator used as follows. int *val, r =10, c= 5; val = new int [r * c]; // create val 2 D array of 10 X 5;

15 Continue.. By Default operator new returns 0. when insufficient free store is available to satisfy its request. Ex int *val = new int; If (val) *val =7 ; else // if val is non-null or non-zero; cout<< Out of memory!! \n ; When an object, created through new is no longer needed, it must be destroyed so that the memory space occupied by it may be released for reuse. This can be done with the help of delete operator.

16 De Allocation of Memory delete operator can be used to de allocated memory. Ex.. delete pointer-variable; Ex.. student *k; k = new student delete k; The arrays allocated through new are freed using the following form of delete; delete [size] pointer-variable; Where size is the number of elements in the array being pointed to pointer variables. In recent version of C++, size in not required. delete []array-name; Ex.. int *t = new int[10]; delete [10]t; or delete []t;

17 Memory Leaks Once we allocate the memory to a pointer object but forget to de allocate it. This cause the memory block. A certain function that dynamically allocates memory to some object but forget to de allocate the reserved memory. This situation is known as memory leak. Many possible reasons for memory leak Forgetting to delete something that has earlier allocated new Failing to notice that code may bypass delete statement under certain circumstances. Assigning the result of a new statement to a pointer that was already pointing to an allocated objects. Warnings!!!!!!!!!!!!!!! Improper use of new and delete may lead to memory leaks.

18 Pointers and Arrays Array and Pointers are very closely linked. C++ treats the name of the array as it a pointer. C++ interprets the name of the array as the address of the first element of the arrays called the Base Address of Array. Base Address of the array can not be changed further. int *a; // a is a pointer to an int int age[5]; // age is an array holding 5 integer; cout<<"enter value for array age \n "; for(int i=0;i<5;i++) a=age; cout<<"\n a point to <<*a; cout<<"\n age point to <<"*age; } Let int age[5]={5,6,8,9,10}; Then the output of the program will be a point to 5 age point to 5

19 Array of Pointers Pointer also may be array type. To declare an array holding 10 int pointers, The declaration would be as follows. int *cs[10]; After the declaration contiguous memory would be allocated for 10 pointers 205 Now each of the pointers, the element of pointer array may be initialized. To assign the address of an integer variable amt to the forth element of the pointer array. We will write cs[3]=&amt; amt 205

20 int *cs[5] Array cs address int a = 10, b = 23, c = 40, k = 25, r = 6; a b c k r ` cs[0]=&a; cs[1]=&b; cs[2]=&c, cs[3]=&k; cs[4]=&r; now cs is 0 1` Array cs address

21 Pointers and String We know that C++ treats a string as an array of characters,. A string is one dimensional array of characters terminated by a null \0 characters. Ex.. char name[]= Pointers ; // declares a string; For (int i=0;i!= \0 ;i++) cout<<name[i]; Alternatively the same will achieve using the pointers also; char name[]= Pointers ; // declares a string; char *cp For (cp=name; cp!= \0 ;cp++) cout<<*cp;

22 Array of Char Pointers An array of char pointer is very popularly used for storing several strings in memory. Ex char *name[] = { Sachin, Ram, Kumar, Sunil, Anil }; In the above declaration name is an array of char pointer whose element pointers contains base addresses of respective names. Here the element name[0] contains the base address of string Sachin, similarly name[1] contains the base address of string Ram and so on. The array of pointers makes more efficient use of available memory. An array of pointers makes the manipulation of the string much easier.

23 Array of pointers pointing several strings S a c h i n \0 R a m \0 K u m a r \0 S u n i l \0 A n i l \0 Name [] Now what will the output of the following lines char *cp; cp=name[3]; cout<<*cp<<*(cp+2)<<*++cp Output Snu

24 Pointers And Const A constant pointer means that the pointer in consideration will always point to the same address. Its address can not be modified In the following lines We shall declare four variables. (1) a pointer call ptr (2) a constant pointer called cptr (3) a pointer named ptrc pointing to constant (4) a constant pointer cprc pointing to constant. int a = 64; // an int int *ptr = &n // a pointer to an int ++(*ptr) // increment to *prt; int *const cptr = &n // a const pointer to an int ++(*cptr); // increment to *cptr ++cptr; // error // constant pointer can not change their address const int kn = 88; // a const int const int *ptrc = &kn; // a pointer to const int ++(*ptrc) // error content cannot be modify ++ptrc; // increment pointer ptrc const int *const cptrc = &kn; // a const pointer to const int ++(*cptrc); // error ++cptrc; //error

25 Pointers and Function A Function is user defined operation that can be invoked by applying the call operator ( ( ) ) to the function s name. If the function expects to receive arguments, these arguments (actual arguments) are placed inside the call operator. The arguments are separated by comma. A function may be invoked in two ways (1) Call by value (2) Call by reference The second method can itself be used in two ways. (1) By passing the reference (2) By passing the pointers A reference is an alias name for a variable, the following code float value = ; float &amt = value; Here amt and value refer the same location of the memory, if the one have change their value the other also got change their values.

26 Invoking function by passing the reference When parameters are passed to the function by reference, then the formal parameters become reference to the actual parameters in the calling funtion. The call by reference method is useful in situation when the values of the original variables are to be changed using a function. float value = ; float *fp = &values ; float &amt = value; Here all the following print the same value ; cout<<value; cout<<*fp; cout<<amt;

27 Swap Call by reference #include<iostream.h> #include<conio.h> void swap(int &a, int &b) { int t; // a=a+b; t=a; // b=a-b; a=b; // a=a-b; b-t; } void main() { int x,y; clsrcr(); cout<<endl<<"enter two values "; cin>>x>>y; cout<<"\n Before Swap \n "; cout<<" x = "<<x<<" y = "<<y; swap(x,y); cout<<"\n After Swap \n "; cout<<" x = "<<x<<" y = "<<y; getch(); } Swap Call by pointers #include<iostream.h> #include<conio.h> void swap(int *a, int *b) { int t; // a=a+b; t=*a; // b=a-b; *a=*b; // a=a-b; *b-t; } void main() { int x,y; clsrcr(); cout<<endl<<"enter two values "; cin>>x>>y; cout<<"\n Before Swap \n "; cout<<" x = "<<x<<" y = "<<y; swap(&x,&y); cout<<"\n After Swap \n "; cout<<" x = "<<x<<" y = "<<y; getch(); }

28 Function Returning Pointers The way a function can returns an int, a float, a double or reference or any other data types. It can even returns a pointers. However function declaration must replace it. Syntax type *function_name ( argument list); Here the type may be any type. #include<iostream.h> #include<conio.h> int *big(int &x, int &y) { if (x>y) return (&x); else return(&y); } void main() { int a,b,*g; clrscr(); cout<<"enter two no "; cin>>a>>b; g=big(a,b); cout<<"\n Big Number is "<<*g; getch(); }

29 Pointer And Structure C++ allows pointers to structures just as it allows pointers to int or float or any other data type. Declaration and Use. struct-name *structure-pointer Where struct-name is the already declare struct name and structure-pointer is the struct pointer variable. Ex. struct date { int dd,mm,yy; }; struct date *ptrdate;

30 Continue. Using structure pointer, the member of structure are accessed using the -> operator. It can be written as struct-pointer->struct-member; As the above example. ptrdate->dd, ptrdate->mm, ptrdate->yy; There are two primary uses for structure pointers 1. To generate a call by reference call to a function 2. To create dynamic data structure like linked list, stack, queues, trees etc. Using C++ dynamic allocation system.

31 Self Referential Structure A structure having a member element that refers to the structure itself is known as self-referential structure. Empno Name Amar Anuj Sheeba Basic Experience Next

32 Dynamic Structure The new operator is used to create dynamic structure the structure for the memory is allocated dynamically. SYNTAX. Struct-pointer = new struct type; Ex.. employee *ptr; ptr = new employee; This dynamic structure is released by the de allocation operator delete. delete ptr;

33 Object as a function Arguments Object are passed to function in the same way as any other type of variable is passed. This means object may be passed both ways - through call by value and through call by reference Passing Object through call by value.--- In this way the called function creates a copy of the passed object. However the fact that a copy is created. Here two questions generated (1) Is the object s constructor executed when the copy of the passed object is made. (2) Is the destructor executed when the copy is destroyed. What are the solutions of these problems?

34 #include<iostream.h> class sample { int x; public: sample(int i) { x = i; cout<< "Constructing object with "<<x<<"\n"; } ~sample() { cout<< "Destroying object having "<<x<<"\n"; } void put_x(int i) { x = i ; } int get_x() { return x; } }; void func(sample s1) { s1.put_x(2); cout<<" This is x local to fun() \n "; cout<<"x = "<<s1.get_x()<<"\n"; } void main() { sample s(1); cout<<" This is the main () "; cout<" x = "<<s.get_x()<<"\n"; func(s); cout<< "Back is Main () \n "; cout<<"x = "<<s.get_x()<<"\n"; } Output This is the main() x = 1 This is x local to func() x = 2 Destroying object having 2 Back in main() x = 1 Destroying object having 1

35 Passing object through References We know that when an object is passed by value to a function a copy of that object is made without invoking its constructor. However when function terminates the copy s destructor is called. If you want to called function to work with the original object so that there is no need to create and destroy the copy of it, You may pass the reference of the object, then called function refers the original object.

36 #include<iostream.h> class sample { int x; public: sample(int i) { x = i; cout<< "Constructing object with "<<x<<"\n"; } ~sample() { cout<< "Destroying object having "<<x<<"\n"; } void put_x(int i) { x = i ; } int get_x() { return x; } }; void func(sample &s1) { s1.put_x(2); cout<<" This is x local to fun() \n "; cout<<"x = "<<s1.get_x()<<"\n"; } void main() { sample s(1); cout<<" This is the main () "; cout<" x = "<<s.get_x()<<"\n"; func(s); cout<< "Back is Main () \n "; cout<<"x = "<<s.get_x()<<"\n"; } Output This is the main() x = 1 This is x local to func() x = 2 Destroying object having 2 Back in main() x = 2 Destroying object having 1

37 Pointers And Objects Just like other pointers, the object pointer are declared by placing in front of a object pointer s name. Its form as follows class-name *object-name; Where class-name is the name of an already defined class and object pointer is the pointer to an object of this class type. student *k; Here student is the class name and k is the pointer type object. When accessing members of the class using object pointer, the arrow (->) operator is used instead of dot (.) operator.

38 Ex.. #include<iostream.h> class time { int hh,mm,sss; public: time() { hh=mm=ss=0;} void readdata() {... } void printdata() {... } }; void main() { time t, *pt; t.readdata()' t.printdata(); pt = &t; pt->printdata(); }

39 this pointer Whenever you define a class, the member function are created and placed in the memory space only once. It means only one copy of member functions is manipulated that is shared by all the objects of the class. Now there is a problem? If only one instance of a member function exist, how does it come to know which object s data member is to be manipulated? The solution of this problem is this pointer, when a member function is called, it is automatically passed an implicit argument that is the pointer of the object that invoked the member function. This pointer is called this. EX. In a bank there are many accounts. The account holder can withdraw amount or view their bank balance through ATM (Automatic Teller Machine). Now ATMs can withdraw from any account in the bank, but which account are they supposed to work upon? This is resolved by the ATM card. By card account number is passed implicitly to the machine.

40 #include<iostream.h> #include<conio.h> #include<string.h> class salesman { char name[25]; float tsales; public: salesman(char *sn,float amt) { strcpy(name,""); strcpy(name,sn); tsales=amt; } void printobject() { cout<<this->name; cout<<" has inovoked printobject \n"; } }; void main() { salesman raman("raman",4500),ved("ved",5 000),vedant("Vedant",6000); clrscr(); raman.printobject(); ved.printobject(); vedant.printobject(); getch(); } OUTPUT Raman has inovoked printobject Ved has inovoked printobject Vedant has inovoked printobject

What is Pointer? Pointer is a variable that holds a memory address, usually location of another variable.

CHAPTER 08 POINTERS What is Pointer? Pointer is a variable that holds a memory address, usually location of another variable. The Pointers are one of the C++ s most useful and powerful features. How Pointers