Outline. Computer Memory Structure Addressing Concept Introduction to Pointer Pointer Manipulation Summary

Transcription

1 Pointers 1

2 2 Outline Computer Memory Structure Addressing Concept Introduction to Pointer Pointer Manipulation Summary

3 3 Computer Memory Revisited Computers store data in memory slots Each slot has an unique address Variables store their values like this: Addr Content Addr Content Addr Content Addr Content 1000 i: j: k: m: a[0]: a 1005 a[1]: b 1006 a[2]: c 1007 a[3]: \ ptr:

4 4 Computer Memory Revisited Altering the value of a variable is indeed changing the content of the memory e.g. i = 40; a[2] = z ; Addr Content Addr Content Addr Content Addr Content 1000 i: j: k: m: a[0]: a 1005 a[1]: b 1006 a[2]: z 1007 a[3]: \ ptr:

5 5 Addressing Concept Pointer stores the address of another entity It refers to a memory location int i = 5; int *ptr; /* declare a pointer variable */ ptr = &i; /* store address-of i to ptr */ printf( *ptr = %d\n, *ptr); /* refer to referee of ptr */

6 6 Why do we need Pointer? Pointers are more efficient in handling arrays and strings Can be used to return multiple values from a function Allows dynamic memory allocation Reduces length and complexity of the program Increases execution speed and thus reduces program execution time Remember this? scanf( %d, &i);

7 7 What actually ptr is? ptr is a variable storing an address ptr is NOT for storing the actual value of i int i = 5; int *ptr; ptr = &i; printf( i = %d\n, i); printf( *ptr = %d\n, *ptr); printf( ptr = %p\n, ptr); Output: i = 5 *ptr = 5 ptr = effff5e0 ptr i address of i 5 value of ptr = address of i in memory

8 8 Twin Operators &: Address-of operator Get the address of an entity e.g. ptr = &j; Addr Content Addr Content Addr Content Addr Content 1000 i: j: k: m: ptr:

9 9 Twin Operators *: De-reference operator Refer to the content of the referee e.g. *ptr = 99; Addr Content Addr Content Addr Content Addr Content 1000 i: j: k: m: ptr:

10 Example: Pass by Reference Modify behaviour in argument passing void f(int j) void f(int *ptr) { { j = 5; *ptr = 5; } } void g() void g() { { int i = 3; int i = 3; f(i); } f(&i); i = 3? } i = 5? 10

11 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 5 j int integer variable 10 11

12 An Illustration int i = 5, j = 10; int *ptr; /* declare a pointer-to-integer variable */ int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 5 j int integer variable 10 ptr int * integer pointer variable 12

13 An Illustration int i = 5, j = 10; int *ptr; int **pptr; /* declare a pointer-to-pointer-to-integer variable */ ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 5 j int integer variable 10 ptr int * integer pointer variable pptr int ** integer pointer pointer variable Double Indirection 13

14 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; /* store address-of i to ptr */ pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 5 j int integer variable 10 ptr int * integer pointer variable address of i pptr int ** integer pointer pointer variable *ptr int de-reference of ptr 5 14

15 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; /* store address-of ptr to pptr */ *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 5 j int integer variable 10 ptr int * integer pointer variable address of i pptr int ** integer pointer pointer variable address of ptr *pptr int * de-reference of pptr value of ptr (address of i) 15

16 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 3 j int integer variable 10 ptr int * integer pointer variable address of i pptr int ** integer pointer pointer variable address of ptr *ptr int de-reference of ptr 3 16

17 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 7 j int integer variable 10 ptr int * integer pointer variable address of i pptr int ** integer pointer pointer variable address of ptr **pptr int de-reference of de-reference of pptr 7 17

18 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 7 j int integer variable 10 ptr int * integer pointer variable address of j pptr int ** integer pointer pointer variable address of ptr *ptr int de-reference of ptr 10 18

19 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 7 j int integer variable 9 ptr int * integer pointer variable address of j pptr int ** integer pointer pointer variable address of ptr **pptr int de-reference of de-reference of pptr 9 19

20 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable 7 j int integer variable 9 ptr int * integer pointer variable address of i pptr int ** integer pointer pointer variable address of ptr *pptr int * de-reference of pptr value of ptr (address of i) 20

21 An Illustration int i = 5, j = 10; int *ptr; int **pptr; ptr = &i; pptr = &ptr; *ptr = 3; **pptr = 7; ptr = &j; **pptr = 9; *pptr = &i; *ptr = -2; Data Table Name Type Description Value i int integer variable -2 j int integer variable 9 ptr int * integer pointer variable address of i pptr int ** integer pointer pointer variable address of ptr *ptr int de-reference of ptr -2 21

22 Pointer Arithmetic What s ptr + 1? èthe next memory location! What s ptr - 1? èthe previous memory location! What s ptr * 2 and ptr / 2? èinvalid operations!!! 22

23 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable)? a[1] float float array element (variable)? a[2] float float array element (variable)? a[3] float float array element (variable)? ptr float * float pointer variable *ptr float de-reference of float pointer variable? 23

24 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable)? a[1] float float array element (variable)? a[2] float float array element (variable)? a[3] float float array element (variable)? ptr float * float pointer variable address of a[2] *ptr float de-reference of float pointer variable? 24

25 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable)? a[1] float float array element (variable)? a[2] float float array element (variable) 3.14 a[3] float float array element (variable)? ptr float * float pointer variable address of a[2] *ptr float de-reference of float pointer variable

26 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable)? a[1] float float array element (variable)? a[2] float float array element (variable) 3.14 a[3] float float array element (variable)? ptr float * float pointer variable address of a[3] *ptr float de-reference of float pointer variable? 26

27 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable)? a[1] float float array element (variable)? a[2] float float array element (variable) 3.14 a[3] float float array element (variable) 9.0 ptr float * float pointer variable address of a[3] *ptr float de-reference of float pointer variable

28 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable)? a[1] float float array element (variable)? a[2] float float array element (variable) 3.14 a[3] float float array element (variable) 9.0 ptr float * float pointer variable address of a[0] *ptr float de-reference of float pointer variable? 28

29 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable) 6.0 a[1] float float array element (variable)? a[2] float float array element (variable) 3.14 a[3] float float array element (variable) 9.0 ptr float * float pointer variable address of a[0] *ptr float de-reference of float pointer variable

30 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable) 6.0 a[1] float float array element (variable)? a[2] float float array element (variable) 3.14 a[3] float float array element (variable) 9.0 ptr float * float pointer variable address of a[2] *ptr float de-reference of float pointer variable

31 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Data Table Name Type Description Value a[0] float float array element (variable) 6.0 a[1] float float array element (variable)? a[2] float float array element (variable) 7.0 a[3] float float array element (variable) 9.0 ptr float * float pointer variable address of a[2] *ptr float de-reference of float pointer variable

32 Pointer Arithmetic and Array float a[4]; float *ptr; ptr = &(a[2]); *ptr = 3.14; ptr++; *ptr = 9.0; ptr = ptr - 3; *ptr = 6.0; ptr += 2; *ptr = 7.0; Type of a is float * a[2] è *(a + 2) ptr = &(a[2]) èptr = &(*(a + 2)) èptr = a + 2 a is a memory address constant ptr is a pointer variable 32

33 More Pointer Arithmetic What if a is a double array? A double may occupy more memory slots! Given double *ptr = a; What s ptr + 1 then? Addr Content Addr Content Addr Content Addr Content 1000 a[0]: a[1]: a[2]:

34 More Pointer Arithmetic Arithmetic operators + and auto-adjus the address offset. Also called as scale factor According to the type of the pointer: sizeof(double) = = 1004 Addr Content Addr Content Addr Content Addr Content 1000 a[0]: a[1]: a[2]:

35 1 /* 2 Using the & and * operators */ 3 #include <stdio.h> 4 5 int main() 6 { 7 int a; /* a is an integer */ aptr. 8 int *aptr; /* aptr is a pointer to an integer */ 9 10 a = 7; 11 aptr = &a; /* aptr set to address of a */ printf( "The address of a is %p" 14 "\nthe value of aptr is %p", &a, aptr ); printf( "\n\nthe value of a is %d" 17 "\nthe value of *aptr is %d", a, *aptr ); printf( "\n\nshowing that * and & are inverses of " 20 "each other.\n&*aptr = %p" 21 "\n*&aptr = %p\n", &*aptr, *&aptr ); return 0; 24 } The address of a is 0012FF88 The value of aptr is 0012FF88 The value of a is 7 The value of *aptr is 7 Proving that * and & are complements of each other. &*aptr = 0012FF88 *&aptr = 0012FF88 The address of a is the value of 1.Declare variables The * operator returns an alias to what its operand points to. aptr points to a, so *aptr returns a. 2 Initialize variables 3. Print Notice how * and & are inverses Program Output

36 Calling Functions by Reference Call by reference with pointer arguments Pass address of argument using & operator Allows you to change actual location in memory Arrays are not passed with & because the array name is already a pointer * operator Used as alias/nickname for variable inside of function void double( int *number ) { *number = 2 * ( *number ); } *number used as nickname for the variable passed

37 1 /* 2 Cube a variable using call-by-reference Notice that the function prototype takes a pointer to an integer (int *). 3 with a pointer argument */ 4 5 #include <stdio.h>5 #include <stdio.h> 6 6 Notice how the address of number is 7 void 7 cubebyreference( void int * int ); */* ); given prototype -/* cubebyreference prototype */ */ expects 8 8 a pointer (an address of a variable). 9 int main() 9 int main() 10 { 10 { 11 int number = 5;11 int number = 5; printf( "The original value of number is %d", number ); 14 cubebyreference( &number ); 15 printf( "\nthe new value of number is %d\n", number ); return 0; 18 } void cubebyreference( int *nptr ) 21 { 22 *nptr = *nptr * *nptr * *nptr; /* cube number in main */ 23 } The original value of number is 5 The new value of number is Function prototype 1.1 Initialize variables 2. Call function Inside cubebyreference, *nptr is used (*nptr is number). 3. Define function Program Output

38 Bubble Sort Using Call-by-reference sizeof Returns size of operand in bytes For arrays: size of 1 element * number of elements if sizeof( int ) equals 4 bytes, then int myarray[ 10 ]; printf( "%d", sizeof( myarray ) ); will print 40 sizeof can be used with Variable names Type name Constant values

39 1 /* 2 This program puts values into an array, sorts the values into 3 ascending order, and prints the resulting array. */ 4 #include <stdio.h> 5 #define SIZE 10 6 void bubblesort( int *, const int ); 7 8 int main() 9 { int a[ SIZE ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; 12 int i; Bubblesort gets the address 13 of array elements (pointers). 14 printf( "Data items in original order\n" ); The name of an array is a 15 pointer. 16 for ( i = 0; i < SIZE; i++ ) 17 printf( "%4d", a[ i ] ); bubblesort( a, SIZE ); /* sort the array */ 20 printf( "\ndata items in ascending order\n" ); for ( i = 0; i < SIZE; i++ ) 23 printf( "%4d", a[ i ] ); printf( "\n" ); return 0; 28 } void bubblesort( int *array, const int size ) 31 { 32 void swap( int *, int * ); 1. Initialize array 1.1 Declare variables 2. Print array 2.1 Call bubblesort 2.2 Print array

40 33 int pass, j; 34 for ( pass = 0; pass < size - 1; pass++ ) for ( j = 0; j < size - 1; j++ ) if ( array[ j ] > array[ j + 1 ] ) 39 swap( &array[ j ], &array[ j + 1 ] ); 40 } void swap( int *element1ptr, int *element2ptr ) 43 { 44 int hold = *element1ptr; 45 *element1ptr = *element2ptr; 46 *element2ptr = hold; 47 } Data items in original order Data items in ascending order Function definitions Program Output

41 Pointers to 2-D array Assume int a[3][4] 41

42 Pointers to 2-D array Assume int a[3][4] A 2-D array is stored in contiguous memory location in row major So 1st element of 2nd row is actually base address + row_number * no of elements in each row In general a[i][j] is eq to *(p + row_count * i + j) eg. a[2][3] is given by *(p+2*4+3) = *(p+11) Hence when a 2-D array is declared using pointer, we need size of row int (*p)[4] Here p is defined to be a pointer to a group of contiguous, one-dimensional, 4-element integer arrays. 42

43 Pointers to 2-D array Since p was defined to be a pointer to a group of contiguous, one-dimensional, 4-element integer arrays. p+1 points to next 1-D array (row # 1) *(p+i) points to first element in the i th row *(p+i) + j - points to j th element on i th row *(*(p+i) + j) - Value stored in cell(i,j) 43

44 Pointers and Strings Strings are treated like character arrays They are declared as char str[5]= Good Compiler automatically inserts the null character at the end of string Strings can be created using pointers char *str = Good It creates a string for the literal and then stores its address in pointer variable str G o o d \0. str 44

45 String handling by pointers

46 Pointer to structure variables

47 Advice and Precaution Pros Efficiency Convenience Cons Error-prone Difficult to debug 47

48 Summary A pointer stores the address (memory location) of another entity Address-of operator (&) gets the address of an entity De-reference operator (*) makes a reference to the referee of a pointer Pointer and array Pointer arithmetic 48