A pointer is a variable that stores the address of another variable, stored at an address in computer memory Hence, it points to another variable

Transcription

1 Pointers 1

2 Pointers A pointer is a variable that stores the address of another variable, stored at an address in computer memory Hence, it points to another variable Purpose: Basis for implementing linked data structures e.g., linked lists, trees, graphs... Provide dynamic memory allocation variable size arrays 2

3 Getting the address of a variable You need to use the address operator & #include <iostream> void main() { int num; num = 22; cout << "num= "<< num << endl; cout << "The address of num = " << &num << endl; } 3

4 Pointers (Contd.) A pointer is defined as: <type> * ptr_variable; ptr_variable stores the address of a memory location that stores a <type> value int num = 22; int *p; num 22 what happens in memory. p.. Null An unititialized pointer is said to point to Junk/Nowhere/Null. Null is defined in standard header files to mean nowhere / nothing. 4

5 Storing address in pointers int num = 22; int * num_addr = &num; 5

6 Dereferencing operator To obtain the contents of the variable pointed to by a pointer, we need to use the dereferencing operator *, followed by the name of the pointer. #include <iostream> void main() { int *num_addr; int miles, dist; miles = 22; num_addr = &miles; cout << "Address stored in num_addr is " << num_addr << endl; cout << "Value pointed to by num_addr is " << *num_addr << endl; dist = 158; num_addr = &dist; cout << "Address stored in num_addr is " << num_addr << endl; cout << "Value pointed to by num_addr is "<<*num_addr << endl; } 6

7 Reference variables A reference variable stores the address of another variable. Reference variables must be initialized when they are declared. #include <iostream.h> void main() { int x = 3; int& y = x; cout << "x= " << x << "y = " << y << endl; y = 7; cout << "x= " << x << "y = " << y << endl; } 7

8 Reference variables (cont.) Very useful for calling a function by reference. void newval(float& xnum, float& ynum) { xnum = 89.5; ynum = 99.5; } 8

9 Differences between references and pointers a) A reference parameter is a constant pointer (after initializing a reference parameter, we cannot change it again). b) References are dereferenced d automatically (no need to use the dereferencing operator *). 9

10 Differences between references and pointers (cont.) int b; // using reference variables int& a= b; a = 10; int b; // using pointers int *a =&b; *a = 10; 10

11 Passing a reference variable to a function The disadvantage is that the function call does not reveal whether the arguments of the function are reference parameters or not!! 11

12 Passing a pointer variable to a function (cont.) #include <iostream> void newval(float *, float *); // function prototype int main() { float firstnum, secnum; cout << "Enter two numbers: "; cin >> firstnum >> secnum; newval(&firstnum, &secnum); // pass the address explicitly!! cout << firstnum << secnum << endl; return 0; } void newval(float *xnum, float *ynum) { *xnum 89.5; // dereferencing is required!! *ynum = 99.5; } 12

13 Array names as pointers When an array is created, the compiler automatically creates an internal pointer constant (i.e., we cannot change its contents) for it and stores the starting address of the array in this pointer The name of the array becomes the name of the pointer constant Referring to the fourth element of the array cause the compiler, internally, to make the following address computation: &arr[3] = &arr[0] + (3 * sizeof(int)) (offset to arr[3] = 3 x 2 = 6 bytes) Alternatively, we can refer to arr[3] as follows: *(arr +3) 13

14 Array names as pointers (cont.) #include <iostream> void main() { const SIZE = 5 int i, arr[size] = {98, 87, 92, 79, 85}; for(i=0; i<size; i++) cout << arr[i] << *(arr + i) << endl; } 14

15 Dynamic Memory Allocation 15

16 Why? Arrays are useful, however we must know in advance about the amount of memory required In many situations, we don t know exact size required until runtime Reserving maximum wastes memory Here comes the concept of dynamic memory allocation 16

17 The new operator C++ provides a different approach to obtain dynamic memory new keyword obtains memory from OS and returns a pointer to starting location char *str = OOP using C++ ; int len = strlen(str); char *ptr; ptr = new char[len+1]; strcpy(ptr,str); cout<<ptr; delete[] ptr; 17

18 new vs. malloc() new plays a similar role to that of C s malloc() It is superior than malloc() in that It returns a pointer to the appropriate data type while malloc() s returned pointer must be cast to appropriate data type There is no keyword in C++ similar to realloc() for changing the size of memory allocated This leaves the responsibility on the programmer to reallocate memory with new and copy previous contents 18

19 The delete operator If your program reserves many chunks of memory using new, eventually all the available memory will be reserved and system will crash To ensure safe and efficient use of memory, new is matched by a corresponding delete If the program terminates the memory is released automatically, however, if a function allocates memory using new and doesn't release it then the pointer is destroyed but not the memory causing waste of memory It is always a good idea to release the memory you allocated Be careful not to use the pointer released by delete 19

20 Dynamic arrays using pointers 20

21 Dynamic Array Allocation To avoid wasting memory, array allocation or deallocation can take place at run time To allocate memory, we need to use the new operator Reserves the number of bytes requested by the declaration. Returns the address of the first reserved location or NULL if sufficient memory is not available. To deallocate memory (which has previously been allocated using the new operator) we need to use the delete operator. Releases a block of bytes previously reserved. The address of the first reserved location is passed as an argument to delete. 21

22 case of 1D arrays cout << "Enter array size: "; cin >> SIZE; int *arr; arr = new int[size]; // allocation delete [] arr; // deallocation 22

23 case of 2D arrays cout << "Enter numrows and numcols: "; cin >> numrows >> numcols; int **arr2d; arr2d = new int* [numrows]; // allocation for(i=0; i<numrows; i++) arr2d[i] = new int[numcols]; for(i=0; i<numrows; i++) // deallocation delete [] arr2d[i]; delete [] arr2d; (individual id elements can be accessed using indices!! (e.g., arr2d[0][2]=10;)) 23

24 Passing a 1D array to a function When an array is passed to a function, its address is the only item actually passed to the function. Passing a 1D array to a function #include <iostream> float find_average(int *, int); void main() { int *arr; arr = new int[numelems]; arr[0] = 2; arr[1] = 18; arr[2] = 1; arr[3] = 27; arr[4]= 16; // or using static memory allocation: const numelems = 5; int arr[numelems] = {2, 18, 1, 27, 16}; cout << "The average is " << find_average(arr, numelems) << endl; } 24

25 Passing a 1D array to a function float find_average(int *vals, int n) { int i; float avg; avg=0.0; for(i=0; i<n; i++) avg += vals[i]; avg = avg/n; return avg; } 25