22/02/2013

Pointers (2.7.2)

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

Pointers & Arrays

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;

200 70 200 51 80 10 20 50 30 40 4900 4892 ????

3

2.7.2 & 2.7.3 (pages 55 - 60)

& : returns LValue (address) of a variable

Read as address of

Pointer Examples
int x = 100; int *p1 = &x; cout << "&x == " << &x << " << "p1 == " << p1 << " *p1 += 20; cout << "&x == " << &x << " << "p1 == " << p1 << " x == " << x << endl x == " << x << endl *p1 == " << *p1 << endl;

pointer

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;
4

Referencing & Dereferencing

& variable

* []

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

in swap_wrong
x: y: temp: 10 20

in swap
px: 4397 py: 9643 temp:

*p1 == " << *p1 << endl;

int z[10], i;

Output
&x == 0x7fff7e60f41c x == 100 p1 == 0x7fff7e60f41c *p1 == 100 &x == 0x7fff7e60f41c x == 120

in caller:
a:4397 b:9643 10 20

int *ptr, i;

Note: x = 10;
5

p1 == 0x7fff7e60f41c *p1 == 120

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.

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]

1 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 7832

12 34 56 78 78 56 34 12
9

12 34 56 44 33 56

pa-2

pa-1

pa:

pa+1 pa+2

pa+3
7832 7833

7833

ip0x7832 *ip=0x3412 ip+10x7834 ip[1]=0x4456 ip+20x7836 ip[2]=0x5633

7833 7834 7835 7836 7837 7838 7839

lp0x7832 *lp= 0x78563412

12 34 56 44

7834 cp 7832 *cp=0x12 7835 7836 cp+2 7834 cp[2]=0x56 7837

a: a[0] a[1] a[2] a[3] a[4] a[5]

7834 7835

lp+10x7836 lp[1]= 0x12345678

pointer int pointer

7 8

22/02/2013

2-- Assignment of Pointers

Pointers of same types can be assigned.
float x = 10.5, *p = &x, *q = p;

3 Comparing/Subtraction to Pointer
The resulting type of subtracting two pointers is integer. Comparison Vs. Subtraction a<bab<0 a == b a b == 0 a>bab>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 != \0) p++; return p s; }
10

4 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 ... }

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

NULL can be used instead of 0

pointer - pointer int
11 12

Provides some degree of Polymorphism.

Pointer Vs Array
char amessage[] = now is the time; // an array
amessage: now is the time\0

strcpy example
/* strcpy: copy t to s */ void strcpy(char *s, char *t) { int i; i = 0; while ((s[i] = t[i])!=\0) i++; }

Pointer Vs Array
Note: if you just write s=t then only the pointer will be copied, not the characters

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[ ])

char *pmessage
pmessage:

= now is the time; // a pointer

now is the time\0

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++) ; } char p[25]; char *q = Hello world; strcpy(p, q);
14

pmessage has LValue pmessage is pointer and requires 2/4 bytes for itself pmessage++ is possible pmessage=somepointer is legal amessage has no LValue amessage is a name for the starting address of the array amessage++ is illegal amessage=somepointer is illegal
13

s: t:

4397 9643

/* strcpy: copy t to s */ void strcpy(char *s, char *t) { while ((*s = *t)!=\0) { s++; t++; } }

/* strcpy: copy t to s */ void strcpy(char *s, char *t) { while ((*s++ = *t++)!=\0) ; }

4397 p: q: Hello world\0 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] == \0) return 0; return s[i] t[i]; }

const and Pointers

const int w=20; int x, y;

References

const int w=20; int x, y;

const qualifier can be used with pointers in three ways: Prohibit a pointer from changing its content
const int *p1 = &w; // p1 can point to (non-)const int *p1 = 200; // invalid : content cant change p1 = &x; // OK. p1 points to x (non-const) int const *p2; // p2 and p2 is identical to

C++ reference is short hand for const pointer (* const)

int &r1 = x; // same as: int * const r1 = &x

References must be initialized at declaration and cant change Referencing and dereferencing are implicitly done by C++
r1 = r1 + 5 + w; // not for using *r1

Prohibit a pointer from changing its reference:

/* 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 == \0) return 0; return *s *t; }

Address of reference means its targets address.

cout << (&r1 == &x); // output: 1

int * const p3 = &x; // must be initialized at creation p3 = &y; // invalid: reference cant change *p3 = 123; // OK. changes value of x

Useful with functions for pass-by-reference

void swap(int &a, int &b) { int t = a; // a and b are passed by reference a = b; b = t; }
17 18

Prohibit a pointer from changing both reference & content:

const int * const p4 = &w; // must be initialized at creation & point to const int

16

22/02/2013

Dynamic Memory Management

Program image in RAM Environment variables Static Data Stack

2.15 p-89

Dynamic Memory Allocation

// Allocating array int *parr = new int[10]; delete [] parr; // Allocating data for reference struct Foo { char c1, c2; }; Foo *p = new Foo(); p->c1 = X; delete p; // explicit free // Allocating data for reference Foo &r = *new Foo(); r.c1 = X; delete &r; // explicit free
20

Pointer Anomalies
Uninitialized variable : Before storage can be used, it must be allocated.
Foo *p; p->c1 = R; // forget to initialize pointer with new // places R at some random location in memory

Can be accessed via getenv function

char *gvar = some string; int max_size = 200; int myfunc(int x) { int y = 20; x = x + y; return x * y; } int main(void) { int *px = new int; cin >> x; cout << myfunc(x); delete px; }
19

After storage is no longer needed it must be explicitly deleted otherwise memory leak results.
Foo *p = new Foo; p = new Foo; // forgot to free previous storage

Heap

After storage is deleted, it must not be used:

delete p; p->c1 = R; // result of dereference is undefined

Program code

p is called a dangling pointer.

21

Pointers Vs. Multi-dim Arrays

int m[10][20] m m is a 2D array: 200 int sized locations have been set aside 10 m[row][col] is calculated as 20row+col int *pm[10] pm is a 1D 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) ppm c[i] must be initialized/allocated with code (or static initialized (like name array) Examples in next slide
20

Pointers Vs. Multi-dim Arrays

Multi-dimensional Array : Formal Param.

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]) { }

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; 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; }
22

10 11 12 13 20 21 22 23 30 31 32 33

pm
10

The brackets in last statement is necessary since [ ] have higher precedence than *.
int (*daytab)[13] : a pointer to an array of 13 elements
0 daytab 12

int *daytab[13] : an array of 13 pointers to integers.

23

daytab[0] [1]

[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

Complicated Declarations
char (*(*x())[5])()

Command-line Arguments

(2.11 p-79)

char ( * ( * x () ) [5] ) ()

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)

int *f()

int * f ()

f is a function returning int *

x is a function returning pointer to array[5] of pointer to function returning char

echo.c invoked with: echo hello world

argc is 3 and argv is
argv [0] [1] echo\0 hello\0 world\0 0

char (*(*x[3])())[5]
int (*f)() int ( * fp ) () fp is a pointer tofunction returning int

#include <iostream> int main(int argc, char **argv) { for (int i = 1; i < argc; i++) std::cout << argv[i] << " "; std::cout << endl; }

[2] [3]

x is a array[3] of pointer to function returning pointer to array[5] of char

25 26 27

22/02/2013

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 } } }
argv ++argv (*++argv) 0 x f r
\0

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 } } }
argv ++argv[0] argv[0] 0 x f r
\0

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

// for each option in the group

find.exe\0 (*++argv)[0]

find.exe\0

BEWARE: int *comp(void *, void *)

means that comp is a function that that returns int * and takes two void * type arguments

*++argv[0] -m\0

-m\0

int result = (*comp)(&x, &y)

invokes comp with parameters x and y

28

29

30

Pointer to Function : Example

Be Careful with * and ++/-* and ++ / -- are executed from right to left
char *p = XAD; char *q = p; char c;

Coercion: Storage of Values in Memory

Same memory location can be interpreted in different ways: long int
Intrepreted as 1 long int

41

43

45

47

0x41434547

Statement
c = ++*q; c = *++q; c = *q++;

q p p+1 p+1 p

Comment
Increment content of q and return new value. (*q)++; c = *q; Increment q and fetch content. q++; c = *q; fetch content of q and then increment q. i.e., c = *q; q++; Return content of q and then increment content of q. i.e. c = *q; (*q)++;

7832 7833 7834 7835

47 45 43 41
Intrepreted as 2 short int

short int 45 41 char 47 47 43

Y YAD A XAD X XAD

0x4547 0x4143

G E C A Note: All numbers in this slide are in hexadecimal system.

33

4-bytes in RAM

Intrepreted as 4 char

45 43

c = (*q)++; X YAD

The above is also true for the operator.

31 32

Higher bits stored in higher address

41

Coercion: Assignment of Pointers

Cast and then assign
int i = 0x4145, *ip = &i; char *cp = (char *)ip; cout << *cp << endl << cp[1] << endl << showbase << hex << int (*cp) << endl << int (cp[1]) << endl << *ip << endl ;
cp:8996 *cp: 78 38 *(cp+1): i:7838 7839 45 41 78 38 ip:8976
RAM bytes

Coercion: Assignment of Pointers

Cast and then assign
long int l = 0x41434547, *lp = &l; int *ip = (int *)lp; // same as int *ip = (int *)&l; char *cp = (char *)lp; // same as char *ip = (char *)&l;

Coercion: Assignment of Pointers

Cast and then assign
long int char cout int l = 0x41434547, *lp = &l; *ip = (int *)lp; *cp = (char *)lp; << *cp << *(cp+1) << *(cp+2) << *(cp+3) << *ip << *(ip+1) << *lp;

lp:8974 l:7832 E A 7833 7834 7835

Logical View

78 32 78 32 78 32

47 45 43 41

ip:8976 cp:8978

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.

7832 7833 7834 7835

47 45 43 41

*cp=G *(cp+1) =E *(cp+2) =C *(cp+3) =A

7832 7833 7834 7835

47 45 43 41
*(ip+1) 0x4143 *ip 0x4547

7832 7833 7834 7835

47 45 43 41
*lp 0x41434547

hi-8bits[7839] *ip: lo-8bits [7838]

41 45
34

RAM bytes
35

RAM bytes

RAM bytes

RAM bytes
36