Lecture 5 Pointers 1 Variable memory location address

Lecture 5 Pointers 1. Variable, memory location, address, value 2. Concepts of pointers 3. Examples of pointer usage

Variable: name, memory location, value • Every variable in C has a name and a value associated with it. When a variable is declared, a specific block of memory within the computer is allocated to hold the value of that variable. The size of the allocated block depends on the type of the data, e. g. 4 for int x = 10; • When this statement executes, the compiler sets aside 4 bytes of memory to hold the value 10. It also sets up a symbol table in which it adds the symbol x and the relative address in memory where those 4 bytes are set aside. © Oxford University Press 2014. All rights reserved.

Variable, address • Thus, every variable in C has a value and an a memory location associated with it. • The & operator retrieves the address of x, i. e. , the address of the first memory cell of the memory location. © Oxford University Press 2014. All rights reserved.

Variable: name, memory location Variable name x reference to memory location 65329 10 address at memory location Value stored in either big endian or little endian format. 65325 65324 int x = 10; x represents variable name (e. g. an assigned name for a memory location ) &x represents the starting address of the location of x, e. g. 65325 *(&x) or x represents the value of at location x, 10

Program example #include<stdio. h> int main() { int x = 10; printf("Value of x is %dn", x); printf("Address of x in Hex is %pn", &x); printf("Address of x in decimal is %lun", &x); printf("Value at address of x is %dn", *(&x)); return 0; } Value of x is 10 Address of x in Hex is 0061 FF 0 C Address of x in decimal is 6422284 Value at address of x is 10

2. Concept of Pointers • A pointer is a variable that contains the memory address of another variable. • The general syntax of declaring pointer variable is data_type* ptr_name; • The '*' informs the compiler that ptr_name is a pointer variable and data_type specifies that it will store the address of data_type variable. © Oxford University Press 2014. All rights reserved.

Dereferencing a Pointer Variable § We can "dereference" a pointer, i. e. refer to the value of the variable to which it points by using unary '*' operator as in *ptr. § That is, *ptr has value 10, since 10 is value of x. © Oxford University Press 2014. All rights reserved.

Example of Pointer int x = 10; int *p = &x; If pointer p holds the address of variable a, we say p points to a *p represents the value stored at address p *p is called dereferencing of pointer p • Using pointer to get the memory address of anther variable, as well as the value of that variable

pointer int x = 10; int *ptr; ptr = &x; 65329 variable name pointer variable name x 65325 10 65324 ptr 65320 65325 *ptr

Variable vs Pointer 65329 Variable int x = 10; &x represents address of x x represents the value stored 65325 at &x 65324 10 10 int *p; *p = 10; // this is not correct. Pointer int *p; p is declared to be an int pointer p = &a; p holds address of a, i. e. 65325 *p represents the value stored at p, ie. 10 int b = *p; b will have value 10. *p = 20; a will have value 20.

Pointer example #include<stdio. h> int main() { int x = 10; int *ptr; ptr = &x; printf("Value of x is %dn", x); printf("Address of x is %lun", (unsigned long int) &x); printf("Value of pointer ptr is %lun", (unsigned long int) ptr); printf("Address of pointer ptr is %lun", (unsigned long int) &ptr); printf("Ptr pointing value is %dn", *ptr); return 0; Value of x is 10 } Address of x is 6422284 Value of pointer ptr is 6422284 Address of pointer ptr is 6422280 Ptr pointing value is 10

Why pointer? 1. Pointers provide an alternative way to address memory location of data type and its stored value 2. As variables, pointers make it possible to do address operations, so as to access memory space for data operations 3. More features: – – Pointers support dynamic memory management. Pointer helps to return multiple values from a function through function argument Pointer increases program execution speed Pointer is an efficient tool for manipulating complex data structures like linked lists, queues, stacks, trees etc.

Pointer Expressions and Arithmetic • Pointer variables can also be used in expressions. For example, int num 1=2, num 2= 3, sum=0, mul=0, div=1; int *ptr 1, *ptr 2; ptr 1 = &num 1; ptr 2 = &num 2; sum = *ptr 1 + *ptr 2; // the value of sum is ? mul = sum * *ptr 1; // the value of mul is ? • We can compare pointers by using relational operators in the expressions. For example p 1 > p 2 , p 1==p 2 and p 1!=p 2 are all valid in C. © Oxford University Press 2014. All rights reserved.

Pointer Expressions and Arithmetic • When using pointers, unary increment (++) and decrement (--) operators have greater precedence than the dereference operator (*). • Therefore, the expression *ptr++ is equivalent to *(ptr++). • The expression will increase the value of ptr so that it now points to the next element. • In order to increment the value of the variable whose address is stored in ptr, write (*ptr)++. © Oxford University Press 2014. All rights reserved.

Null Pointers • A null pointer is a special pointer value that is known not to point anywhere. This means that a NULL pointer does not point to any valid memory address. • To declare a null pointer you may use the predefined constant NULL. int *ptr = NULL; § It is used in situations if one of the pointers in the program points somewhere some of the time but not all of the time. § In such situations it is always better to set it to a null pointer when it doesn't point anywhere valid, and to test to see if it's a null pointer before using it. © Oxford University Press 2014. All rights reserved.

Generic Pointers • A generic pointer is pointer variable that has void as its data type. • The generic pointer can be pointed at variables of any data type. • It is declared by writing void *ptr; • You need to cast a void pointer to another kind of pointer before using it. int a = 10; void *ptr = &a; printf("%d", *(int *)ptr); • Generic pointers are used when a pointer has to point to data of different types at different times. © Oxford University Press 2014. All rights reserved.

Pass by reference #include<stdio. h> void add(int*, int) ; int main( void ) { int n = 2, j = 2; add( &n, j); printf( "n = %in", n ); printf( "j = %in", j ); return 0; } /* main */ void add( int* x, int y) { *x = *x + 1; y=y+1; } /* add */ n= 3 j = 2

Pointer to Pointers • You can use pointers that point to pointers. The pointers in turn point to data (or even to other pointers). To declare pointers to pointers just add an asterisk (*) for each level of reference. • For example, if we have: 10 int x=10; 1002 2004 int *px, **ppx; x px=&x; px ppx=&px; Now if we write, printf(“n %d”, **ppx); This would print 10, the value of x. © Oxford University Press 2014. All rights reserved.

Pointer of pointer example #include<stdio. h> int main() { int x = 10, *ptr, **pptr; ptr = &x; pptr = &ptr; Value of x is 10 Address of x in Hex is 0061 FF 0 C Address of x in decimal is 6422284 Value of pointer variable ptr is 0061 FF 0 C (address in Hex) Address of pointer variable ptr is 6422280 The value pointed by Ptr is 10 Address of pointer pptr is 6422276 The value pointed by pptr is 6422284 The pointed by pptr is 10 or 10 printf("Value of x is %dn", x); printf("Address of x in Hex is %pn", &x); printf("Address of x in decimal is %lun", &x); printf("Value of pointer variable ptr is %p (address in Hex)n", ptr); printf("Address of pointer variable ptr is %lun", &ptr); printf("The value pointed by Ptr is %dn", *ptr); printf("Address of pointer pptr is %lun", &pptr); printf("The value pointed by pptr is %lun", *pptr); printf("The pointed by pptr is %d or %dn", **pptr, *(*pptr)); return 0; }

Example of pass by reference #include <stdio. h> void swap(int *, int *); int main() { int i = 5, j = 10; printf("Before exchange, i = %d, j = %dn", i, j); swap( &i, &j); } printf("After exchange, i = %d, j = %dn", i, j); return 0; void swap( int *first, int *second ) { int temp; temp = *first; *first = *second; *second = temp; } Omitting * is a common mistake.

#include <stdio. h> void swap ( int *ptr 1, int *ptr 2 ) { int temp; temp = *ptr 1; *ptr 1 = *ptr 2; *ptr 2 = temp; } void exchange(int *q 1, int *q 2, int *q 3) { if (*q 1 < *q 2) swap(q 1, q 2); if (*q 1 < *q 3) swap(q 1, q 3); if (*q 2 < *q 3) swap(q 2, q 3); } int main() { int a, b, c, *p 1, *p 2, *p 3; scanf("%d, %d", &a, &b, &c); p 1 = &a; p 2 = &b; p 3 = &c; exchange(p 1, p 2, p 3); printf("n%d, %dn", a, b, c); } 6, 3, 9 p 1 p 2 p 3 a 6 b 3 c 9 p 1 p 2 p 3 a 9 b 3 c 6 p 1 p 2 p 3 a 9 b 6 c 3 9, 6, 3 p 1 = &a; p 2 = &b; p 3 = &c; exchange (p 1, p 2, p 3); *q 1 < *q 3 swap(q 1, q 3) *q 2 < *q 3 swap(q 2, q 3)

Function type pointer int max(); int (*p)(); p = max; // declare a function pointer // pointing to function max() c = (*p)(a, b); // use pointer to call the function

Example of function type pointer #include <stdio. h> int mul(int a, int b, int c) { return a*b*c; } int main() { int (*function_pointer)(int, int); function_pointer = mul; printf("The product of three numbers is: %d", function_pointer(2, 3, 4)); } return 0; // ouput: 24

Functions as parameter #include <stdio. h> int max(int, int); int min(int, int); void process(int, int (*)()); int main(){ int max(), min(), (*p)(), a, b, c ; p = max; scanf("%d, %d", &a, &b); c = (*p)(a, b); printf("Max is %dn", c); printf("Max is "); process(a, b, max); printf("n"); } printf("Min is "); process(a, b, min); printf("n"); return 0; int max(int x, int y){ int z; z = x > y? x: y; return(z); } int min(int x, int y){ int z; z = x < y? x: y; return(z); } void process(int x, int y, int (*fun)()){ int result; result = (*fun)(x, y); printf("%d", result); }