Pointers Pointers What is pointer A variable 2

Pointers

Pointers • What is pointer? • A variable (2 or 4 bytes long) that can hold an Address • Why pointers? • Sometimes the only way to express a computation • Usually lead to compact and efficient code • Related operators: - * : can be used in two ways • In declaration : read as pointer, e. g. , int *p; • In accessing : read as content of, e. g. , x = *p; - & : returns LValue (address) of a variable • Read as address of 2

Pointer Examples int x = 70, y = 80, z[4] = {10, 20, 30, 40 }; int *ip; // int pointer ip ip = &x; *ip = 200; // ip is assigned to address of x // content of ip is assigned to 200 y = *ip; ip = &z[2]; *ip = *ip + 20; y = *ip+1; // y is assigned to content of ip // same as *ip += 20; x : 4892 200 70 y : 4894 200 51 80 Z, Z[0] : 4896 10 Z[1] : 4898 20 Z[2] : 4900 30 50 Z[3] : 4902 40 ip : 4904 ? ? 4892 4900 3

Pointer Examples int x = 100; int *p 1 = &x; cout << "&x == " << &x << "p 1 == " << p 1 << " x == " << x << endl *p 1 == " << *p 1 << endl; *p 1 += 20; cout << "&x == " << &x << "p 1 == " << p 1 << " x == " << x << endl *p 1 == " << *p 1 << endl; Output &x == 0 x 7 fff 7 e 60 f 41 c x == 100 p 1 == 0 x 7 fff 7 e 60 f 41 c *p 1 == 100 &x == 0 x 7 fff 7 e 60 f 41 c x == 120 p 1 == 0 x 7 fff 7 e 60 f 41 c *p 1 == 120 4

Pointers in Function arguments • Arguments are passed by value, thus only a copy is passed. void swap_wrong(int x, int y) { int temp; temp = x; x = y; y = temp; } void swap(int *px, int *py) { int temp; temp = *px; *px = *py; *py = temp; } int a = 10, b = 20; swap_wrong(a, b); cout << a << b; swap(&a, &b); cout << a << b; in swap_wrong in swap x: 10 px: 4397 y: 20 py: 9643 temp: in caller: temp: a: 4397 10 b: 9643 20 5

Referencing & Dereferencing pointer & variable * [] • Referencing ( & ): create reference (pointer) to memory location • Dereferencing (*, [ ] ): get the content of memory location Declaration Reference/Pointer/ Address/LValue Dereference/Variable/ Content/RValue int x; &x x int z[10], i; z z+i &z[i] z[0] *(z+i) z[i] int *ptr, i; ptr+i &ptr[i] *ptr or ptr[0] *(ptr+i) ptr[i] Note: x = 10; *(&x) = 10; 6

Pointer Operations • The valid pointer operations are: 1. Adding or subtracting a pointer and an integer (p i) 2. Assignment of pointers of the same type (p = q) 3. Subtracting or comparing two pointers in same array (p q) 4. Assigning or comparing to zero. (p = 0) • All other pointer arithmetic are illegal. 7

1– Addition/Subtraction with int • Used for pointing to different elements in an array int a[6], *pa, x, i; pa = &a[2]; // same as pa = a + 2; *pa pa[0] a[2] *(pa-i) pa[-i] a[2 -i] *(pa+i) pa[i] a[2+i] pa-2 pa-1 pa: pa+1 pa+2 pa+3 a: a[0] a[1] a[2] a[3] a[4] a[5] pointer int pointer 8

Addition/Subtraction with int • Size of the pointed data-type is automatically taken care of. • If address of a pointer (say ptr) is A then address of ptr+i is A+i*sizeof(data-type of ptr) long *lp; int *ip; char *cp; 7832 12 7833 34 7834 56 7835 44 cp 7832 *cp=12 7832 12 7833 34 7834 56 7835 44 7836 33 cp+2 7834 cp[2]=56 7837 56 ip 7832 *ip=3412 ip+1 7834 ip[1]=4456 ip+2 7836 ip[2]=5633 7832 12 7833 34 7834 56 7835 78 7836 78 7837 56 7838 34 7839 12 lp 7832 *lp= 78563412 lp+1 7836 lp[1]= 12345678 9

Assignment of Pointers • Pointers of same types can be assigned. float x = 10. 5, *p = &x, *q = p; • Pointer to void • is used to hold any type of pointer int *ip; void *vp; vp = ip; // type casting is not essential • Cannot be de-referenced without type casting. int x = *vp; // is illegal type casting is a must int y = *((int *)vp); // is ok 10

Comparing/Subtraction to Pointer • The resulting type of subtracting two pointers is integer. • Comparison Vs. Subtraction • a<b a–b<0 • a == b a – b == 0 • a>b a–b>0 • Compared/Subtracted pointers should point in same array. • Example: /* strlen: return length of string s*/ int strlen(char *s) { char *p = s; while (*p != ‘’) p++; return p – s; pointer - pointer int } 11

Comparing/Assigning to Zero • Zero is the only integer that can be assigned to a pointer • Zero is the only integer that a pointer can be compared to. • Use this to initialize a pointer and to check validity char *m = 0; . . . if (m != 0) {. . . safe to use the pointer. . . } • NULL can be used instead of 0 12

Pointer Vs Array amessage: now is the time char amessage[] = “now is the time”; pmessage: char *pmessage // an array now is the time = “now is the time”; // a pointer pmessage is pointer and requires 2/4 bytes for itself pmessage++ is possible pmessage=somepointer is legal amessage is a name for the starting address of the array amessage++ is illegal amessage=somepointer is illegal 13

strcpy example /* strcpy: copy t to s */ void strcpy(char *s, char *t) { int i; i = 0; while ((s[i] = t[i])!=‘’) i++; } /* strcpy: copy t to s */ void strcpy(char *s, char *t) { while ((*s = *t)!=‘’) { s++; t++; } } Note: if you just write s=t then only the pointer will be copied, not the characters /* strcpy: copy t to s */ void strcpy(char *s, char *t) { while ((*s++ = *t++)!=‘’) ; } 14

Pointer Vs Array • In function argument array and pointer are same. i. e. , following declaration/definition of function are equivalent • int strlen(char *str) • int strlen(char str[ ]) • Arguments are passed by value, thus only a copy is passed. /* strcpy: copy t to s */ void strcpy(char *s, char *t) { while (*s++ = *t++) //DO NOTHING; } ……… char p[25]; char *q = “Hello world”; strcpy(p, q); s: 4397 t: 9643 4397 p: q: Hello world 9643 What is the effect of writing s=t? 15

strcmp example // strcmp: return <0 if s<t, 0 if s==t, >0 if s>t int strcmp(char *s, char *t) { int i; for (i = 0; s[i] == t[i]; i++) if (s[i] == ‘’) return 0; return s[i] – t[i]; } // strcmp: return <0 if s<t, 0 if s==t, >0 if s>t int strcmp(char *s, char *t) { for ( ; *s == *t; s++, t++) if (*s == ‘’) return 0; return *s – *t; } 16

Dynamic Memory Management Program image in RAM Can be accessed via getenv function Environment variables Static Data Stack char *gvar = “some string”; int max_size = 200; int myfunc(int x) { int y = 20; x = x + y; Heap return x * y; } int main(void) { int *px Program code = new int; cin >> x; cout << myfunc(x); delete px; } 19

Dynamic Memory Allocation // Allocating array int *parr = new int[10]; delete [] parr; // Allocating data for reference class Foo { …………}; Foo *p = new Foo(); p->c 1 = ′X′; delete p; // explicit free // Allocating data for reference Foo &r = *new Foo(); r. c 1 = ′X′; delete &r; // explicit free 20

Pointer Anomalies • Uninitialized variable : Before storage can be used, it must be allocated. Foo *p; // forget to initialize pointer with “new” p->c 1 = ′R′; // places ′R′ at random location in memory • After storage is no longer needed it must be explicitly deleted otherwise memory leak results. Foo *p = new Foo; // forgot to free previous storage • After storage is deleted, it must not be used: delete p; 21 p->c 1 = ′R′; // result of dereference is undefined

Pointers Vs. Multi-dim Arrays • int m[10][20] • m is a 2 D array: • 200 int sized locations have been set aside • m[row][col] is calculated as 20 row+col • int *pm[10] • pm is a 1 D array of pointers to int. • Only 10 pointers are allocated • pm[i] must be initialized/allocated with code (malloc) or static initialized (like name array) • int **ppm • c is a pointer of pointers to int. • Only 1 pointer is allocated • c must be initialized/allocated with code (malloc) • c[i] must be initialized/allocated with code (or static initialized (like name array) • Examples in next slide 20 m … … 10 … … … pm 10 ppm 22

Pointers Vs. Multi-dim Arrays int m[3][4]; for (int r = 0; r < 3; r++) for (int c = 0; c < 4; c++) m[r][c] = (r+1)*10 + c; 10 11 12 13 20 21 22 23 30 31 32 33 int *pm[3]; for (int r = 0; r < 3; r++) { pm[r] = new int[4]; for (int c = 0; c < 4; c++) pm[r][c] = (r+1)*10 + c; } int **ppm = new int *[3]; for (int r = 0; r < 3; r++) { ppm[r] = new int[4]; for (int c = 0; c < 4; c++) ppm[r][c] = (r+1)*10 + c; } 23

Multi-dimensional Array : Formal Parameters • In function parameter only the left most dimension is unnecessary. • Thus all the following are equivalent: void func(int daytab[2][13]) { … } void func(int daytab[][13]) { … } void func(int (*daytab)[13]) { … } • The brackets in last statement is necessary since [ ] have higher precedence than *. • int (*daytab)[13] : a pointer to an array of 13 elements 0 12 daytab • int *daytab[13] : an array of 13 pointers to integers. daytab[0] [12] 24

Complicated Declarations • Read C declarations using a counter-clock wise spiral • Do not cross a bracket (**a[]) unless all the tokens within the bracket are finished int *f() int (*f)() int * f () int ( * fp ) () f is a function returning int * fp is a pointer to function returning int 25

Complicated Declarations char (*(*x())[5])() char ( * x () ) [5] ) () x is a function returning pointer to array[5] of pointer to function returning char (*(*x[3])())[5] x is a array[3] of pointer to function returning pointer to array[5] of char 26

Command-line Arguments • main is called with two arguments : • int argc: is the number of command-line arguments • char **argv: pointer to array of strings (i. e. , char *) int main(int argc, char **argv) • echo. c invoked with: echo hello world • argc is 3 and argv is argv #include <iostream> int main(int argc, char **argv) { for (int i = 1; i < argc; i++) std: : cout << argv[i] << " "; std: : cout << endl; } [0] echo [1] hello [2] world [3] 0 27

Command-line Arguments /* Processing command-line options: like –abc –x –v */ int main(int argc, char **argv) { while (--argc > 0 && (*++argv)[0] == ‘-’) { // each option group while (c = *++argv[0]) { // for each option in the goup // process the option } } } find. exe argv ++argv (*++argv)[0] (*++argv) 0 x f r -m 28

Command-line Arguments /* Processing command-line options: like –abc –x –v */ int main(int argc, char **argv) { while (--argc > 0 && (*++argv)[0] == ‘-’) { // each option group while (c = *++argv[0]) { // process the option } // for each option in the group } } find. exe argv ++argv[0] 0 x f r *++argv[0] -m 29

Pointers to Functions • In C/C++, a function itself is not a variable • But pointer to function can be created • int (*comp)(void *, void *); • comp is a pointer to function that returns int and takes two void * type arguments • BEWARE: int *comp(void *, void *) • means that comp is a function that returns int * and takes two void * type arguments • int result = (*comp)(&x, &y) • invokes comp with parameters x and y 30

Pointer to Function : Example 31

Be Careful with * and ++/-- • * and ++ / -- are executed from right to left char *p = “XAD”; char *q = p; char c; Statement c p q Comment c = ++*q; ‘Y’ “YAD” p c = *++q; ‘A’ “XAD” p+1 Increment q and fetch content. q++; c = *q; c = *q++; ‘X’ “XAD” p+1 fetch content of q and then increment q. i. e. , c = *q; q++; c = (*q)++; ‘X’ “YAD” p Increment content of q and return new value. (*q)++; c = *q; Return content of q and then increment content of q. i. e. c = *q; (*q)++; The above is also true for the – – operator. 32

Coercion: Storage of Values in Memory • Same memory location can be interpreted in different ways: long int Intrepreted as 1 long int 7832 47 7833 45 7834 43 7835 41 4 -bytes in RAM Higher bits stored in higher address 41 43 45 47 0 x 41434547 short int Intrepreted as 2 short int 45 47 0 x 4547 41 43 0 x 4143 char Intrepreted as 4 char 47 ‘G’ 45 ‘E’ 43 ‘C’ 41 ‘A’ Note: All numbers in this slide are in hexadecimal system. 33

Coercion: Assignment of Pointers • Cast and then assign int i = 0 x 4145, *ip = &i; char *cp = (char *)ip; cout << *cp << endl << cp[1] << endl << showbase << hex << int (*cp) << endl << int (cp[1]) << endl cp: 8996 << *ip << endl ; 78 38 i: 7838 45 7839 41 E *(cp+1): A Logical View 78 38 ip: 8976 RAM bytes *cp: hi-8 bits [7839] *ip: lo-8 bits [7838] 41 45 34

Coercion: Assignment of Pointers • Cast and then assign long int l = 0 x 41434547, *lp = &l; int *ip = (int *)lp; // same as int *ip = (int *)&l; char *cp = (char *)lp; // same as char *ip = (char *)&l; lp: 8974 78 32 l: 7832 47 ip: 8976 78 32 7833 45 cp: 8978 78 32 7834 43 7835 41 Note: lp, ip and cp are all of size 2 bytes though they are pointing to data of different sizes, 4, 2 and 1 bytes, respectively. RAM bytes 35

Coercion: Assignment of Pointers • Cast and then assign long int l = 0 x 41434547, *lp = &l; int *ip = (int *)lp; char *cp = (char *)lp; cout << *cp << *(cp+1) << *(cp+2) << *(cp+3) << *ip << *(ip+1) << *lp; 7832 47 *cp=‘G’ 7832 47 7833 45 *(cp+1) =‘E’ 7833 45 7834 43 *(cp+2) =‘C’ 7834 43 7835 41 *(cp+3) =‘A’ 7835 41 RAM bytes *ip 0 x 4547 *(ip+1) 0 x 4143 7832 47 7833 45 7834 43 7835 41 *lp 0 x 41434547 RAM bytes 36