Pointers 6e2w3h

MODULE 3:POINTERS

 WHAT

IS A POINTER?  DECLARATION OF POINTER VARIABLE  ASG ADDRESS TO A POINTER VARIABLE  DEREFRRENCING POINTER VARIABLE  POINTER TO POINTER  POINTER AND 1D-ARRAY  POINTER AND FUNCTIONS  ARRAY OF POINTER  DYNAMIC MEMORY ALLOCATION  POINTER TO A STRUCTURE  SELF REFERENCING STRUCTURE

A pointer is a variable that stores memory address. Like all other variables it also has a name, has to be declared and occupies some space in memory.  It is called pointer because it points to a particular location in memory by storing the address of that location.  Space occupied by pointer variable in the memory is equal for all types of pointers irrespective of there data type ,since all pointers holds address. 

Some of the uses of pointers are: Accessing array elements  Accessing dynamically allocated memory  Implementing data structure like linked list, tree and graph

 int

a = 10; 1000 10

1002 1004

 How

to print the address

printf(“Address of a is %u”, &a);

Syntax: data_type *pname;

ASTERIK REQUIRED TO DEFINE A POINTER VARIABLE

NAME OF POINTER VARIABLE

EXAMPLE: int *iptr; float *fptr; char *tr1,*tr2;

int *iptr; o

o

o

o

Here iptr is a pointer that should point to variable of type int. Here iptr can be said as “pointer to int” float *fptr; Here fptr is a pointer that should point to variable of type float. Here iptr can be said as “pointer to float”

int *iptr; int i=10; Iptr=&i; i

iptr

10

2408

2408

USED TO DENOTE THE ADDRESS OF VARIABLE NOT THE CONTENT.

3456

iptr holds the address of variable i.

We can initialize pointer at the time of declaration, but in this case the variable should be declared before the pointer. EXAMPLE: int i=10, *iptr=&i; 

It is also possible to assign the value of one pointer variable to other,provided their basic type is same. EXAMPLE: int *p; int i=10, *iptr=&i; p=iptr; o

A

pointer that points nothing is known as NULL POINTER. It contains the value 0.

 The

memory address 0 has special significance, It signals that the pointer is not intended to point to an accessible memory location

#include<stdio.h> int main () { int *ptr = NULL; printf("The value of ptr is : %x\n", ptr ); return 0;

} OUTPUT: The value of ptr is 0

 if(ptr)

OR if(ptr==NULL) /* succeeds if p is not null */

 if(!ptr)

OR if(ptr != NULL) /* succeeds if p is null */

We can access a variable indirectly using pointers. For this we will use indirection operation (*). Example: int a=10; int *pa=&a; *pa=20;

is equivalent to

a=20;

(*pa)++;

is equivalent to

a++;

X=*pa+10;

is equivalent to

x=a+10;

Printf(“%d”,*pa);

is equivalent to

printf(“%d”,a);

NOTE: scanf(“%d”,&a); will be equivalent to scanf(“%d”,pa); Since &*pa=pa

a

ppa

pa

3098

2048

10

6874

3098

2048

int a=10; int *pa=&a; int **pa=&pa; Here type of variable a is int,type of variable pa is (int *) or pointer to int, type of variable ppa is (int **) or pointer to pointer to int.

EXAMPLE int a; int *pa; int **ppa; a = 10; /* take the address of var */ pa = &a; /* take the address of ptr using address of operator & */ ppa = &pa; /* take the value using ppa*/ printf("Value of var = %d\n", a ); printf("Value available at *pa = %d\n", *pa ); printf("Value available at **ppa = %d\n", **ppa);

OUTPUT: Value of a= 10 Value available at *pa = 10 Value available at **ppa = 10 EXPLANATION: **ppa =>*(*ppa) =>*(pa) [since *ppa gives pa] =>a [since *pa gives a]

Main points for understanding the relation between pointer and array: Elements of an array are stored in consecutive memory locations.  The name of an array is a constant pointer that points to the 1st element of the array, i.e it stores the 1st(base) address of array.  When a pointer variable is incrimented it points to the next location of its base type. 

int arr[4]={5,10,15,20,25}; a[0] 5 2000

a[1]

a[2]

10

15

20

25

2008

2012

2016

2004

a[3]

a[4]

We can get the address of an element of array by applying & operator in front of subscripted variable name. #include<stdio.h> main() { int a[5]={5,10,15,20,25}; int i; for(i=0;i<5;i++) { printf(“value of a[%d]=%d\t”,i,a[i]); printf(“address of a[%d]=%u\t”,i,&a[i]); }

a a+1 a+2 a+3 a+4

points to 0th element points to 1st element points to 2nd element points to 3rd element points to 4th element

*a *(a+1) *(a+2) *(a+3) *(a+4)

value of 0th value of 1st value of 2nd value of 3rd value of 4th

&a[0] &a[1] &a[2] &a[3] &a[4]

element element element element element

2000 2004 2008 2012 2016

a[0] 5 a[1] 10 a[2] 15 a[3] 20 a[4] 25

Program to print the value and address of elements of an array. #include<stdio.h> void main() { int i,a[5]={5,10,15,20,25}; for(i=0;i<5;i++) { printf(“value of a[%d]=%d\t”,i,*(a+i)); printf(“address of a[%d]=%u\t”,i,a+i); } }

 USING

POINTER ARITHMETIC C pointer is an address which is a numeric value. Therefore, you can perform arithmetic operations on a pointer just as you can a numeric value. There are four arithmetic operators that can be used on pointers: ++, --, +, and -

EXAMPLE OF POINTER ARITHMETIC #include <stdio.h> int main () { int a[5] = {10,15, 20,25}; int i, *ptr; /* let us have array address in pointer */ ptr = a; /* asg base address of array to ptr*/ for ( i = 0; i < 5; i++) { printf("Address of var[%d] = %u\n", i, ptr ); printf("Value of var[%d] = %d\n", i, *ptr ); /* move to the next location */ ptr++; } return 0; }

OUTPUT: Address of a[0] = 2000 Value of a[0] = 5 Address of a[1] = 2004 Value of a[1] = 10 Address of a[2] = 2008 Value of a[2] = 15 Address of a[3] = 2012 Value of a[2] = 20 Address of a[2] = 2016 Value of a[2] = 25

EXPLAINATION: a[0]

a[1]

a[2]

a[3]

a[4]

5

10

15

20

25

2000

2004

2008

2012

2016

ptr

 ptr points to the base address of array. ptr++ increase ptr by 1 integer address (i.e the next location in the array)

 POINTER

COMPARISIONS Pointers may be compared by using relational operators, such as ==, <, and >.

EXAMPLE OF POINTER COMPARISONS #include <stdio.h> int main () { int var[] = {10, 100, 200}; int i, *ptr; /* let us have address of the first element in pointer */ ptr = var; i = 0; while ( ptr <= &var[i] ) { printf("Address of var[%d] = %u\n", i, ptr ); printf("Value of var[%d] = %d\n", i, *ptr ); /* point to the previous location */ ptr++; i++; } return 0; }

OUTPUT: Address of var[0] = 1000 Value of var[0] = 10 Address of var[1] = 1002 Value of var[1] = 100 Address of var[2] = 1004 Value of var[2] = 200 value

address

10

1000

100

1002

200

1004

SOME TRICKS WITH POINTER ARITHMETIC: What is the result of running the following code? void main() { int arr[] = {1, 2, 3}; int *ptr; ptr = arr; printf("arr[0] = %d, arr[1] = %d, arr[2] = %d, ptr = %u, *ptr = %d\n", arr[0], arr[1], arr[2], ptr, *ptr); *ptr++ = 10; printf("arr[0] = %d, arr[1] = %d, arr[2] = %d, ptr = %u, *ptr = %d\n", arr[0], arr[1], arr[2], ptr, *ptr); *++ptr = 20; printf("arr[0] = %d, arr[1] = %d, arr[2] = %d, ptr = %u, *ptr = %d\n", arr[0], arr[1], arr[2], ptr, *ptr); (*ptr)++; printf("arr[0] = %d, arr[1] = %d, arr[2] = %d, ptr = %u, *ptr = %d\n", arr[0], arr[1], arr[2], ptr, *ptr); }



ptr = arr 



This will make the pointer ptr point to the first element in the array arr.

*ptr++ = 10 post-increment (++) has higher presedence than (*) operator, hence (++) will be applied first. Once it’s applied, it will not affect the value of ptr until the statement completes execution. ptr is still pointing to the first element of the array (arr[0]). Now, we apply the * operator to the ptr operand. This will dereference the pointer and will let us access the content it points to. Since it’s pointing to arr[0], *ptr = 10 will set the value of arr[0] to 10. After the statement completes execution, the pointer ptr is incremented and thus will point to the next element in the array (arr[1]).



*++ptr = 20 The increment operator (++) takes precedence over the dereference operator (*).  Since this is a pre-increment operator, ++ptr will make the pointer point to the next element in the array arr[2]. *ptr = 20 will then set the value of arr[2] to 20. 



(*ptr)++ *ptr will point us to arr[2] and thus running (*ptr)++ will increment the value of the integer that ptr is pointing to. So the value of arr[2] will be incremented by 1 once the statement completes execution and the pointer ptr will still point to arr[2].  If we try to compile (*ptr)++ = 0 we will get the following compilation error: “error C2106: „=‟ : left operand must be l-value”. 

OUTPUT: arr[0] = 1, arr[1] = 2, arr[2] = 3, ptr = 0043FE44, *ptr = 1 arr[0] = 10, arr[1] = 2, arr[2] = 3, ptr = 0043FE48, *ptr = 2 arr[0] = 10, arr[1] = 2, arr[2] = 20, ptr = 0043FE4C, *ptr = 20 arr[0] = 10, arr[1] = 2, arr[2] = 21, ptr = 0043FE4C, *ptr = 21

Argument to the function can be ed in 2 ways:  Call by value Call by address CALL BY VALUE: #include<stdio.h> Void main() { int a=5,b=8; printf(“Before calling function, a=%d and b=%d”,a,b); fun(a,b); printf(“After calling function, a=%d and b=%d”,a,b); } void fun(int x,int y) { x++; Y++;

printf(“inside function, x=%d and y=%d”,a,b); }

EXPLANATION: a

5

x

2000

b

8 2004

main()

5

a

2012

y

8 2016 fun()

Before execution of function

5

x

2000 b

8 2004 main()

6 2012

y

9 2016 fun()

After execution of function

Call by address: #include<stdio.h> Void fun(int *x, int *y); Void main() { int a=5,b=8; printf(“Before calling function, a=%d and b=%d”,a,b); fun(&a,&b); printf(“After calling function, a=%d and b=%d”,a,b); } void fun(int *x,int *y) { (*x)++; (*Y)++;

printf(“inside function, x=%d and y=%d”,*x,*y); }

a

5

x 2000

2000

b

8 2004

main()

y

6

2000

2012

2000

2012

2004

9

2004

2016

2004

2016

fun()

Before calling the function

main()

fun()

After calling function

We can have functions that return a pointer. Prototype syntax: data_type *function_name(arguments); Calling : Data_type *p; p=function_name(arguments);

Example: int *fun(int); void main() { int i=10,*p; p=fun(i); printf(“The value =%d”,*p); }

int *fun(int i) { i=i+10; return &i; }

OUTPUT: value =20

C programming language allows you to a pointer to a function. To do so, simply declare the function parameter as a pointer type.  PROTOTYPE: int factorial(int *);  DECLARATION: int factorial(int *ip) { //function body }  CALLING int a = 10; int *p = &a; int f = factorial(p); 

 There

may be a situation when we want to maintain an array which can store pointers to an int or char or any other data type available.

 DECLARATION:

int *ptr[10]; This declares ptr as an array of 10 integer pointers. Thus, each element in ptr, now holds a pointer to an int value.

#include <stdio.h> int main () { int var[] = {10, 100, 200}; int i, *ptr[MAX]; for ( i = 0; i < 3; i++) { ptr[i] = &var[i]; /* assign the address of integer. */ } for ( i = 0; i < 3; i++) { printf("Value of var[%d] = %d\n", i, *ptr[i] ); } return 0; }

OUTPUT: Value of var[0] = 10 Value of var[1] = 100 Value of var[2] = 200

In fixed arrays the memory allocation is static in nature, which is allocated at compile time

Problems of using fixed size arrays:  Possibility

of OVERFLOW  Wastage of Memory

Solution: DYNAMIC MEMORY ALLOCATION Or memory allocated at runtime(at the time of execution) At run time we can:  Allocate memory  Deallocate memory

 Malloc()

void* malloc(size_t size)  request a contiguous block of memory of the given size.  returns a pointer to that block or NULL if the request is not satisfied  The type size_t is essentially an unsigned long that indicates how large a block is needed. Measured in bytes.  Because the block pointer returned is void pointer a type casting is needed when storing the void pointer in a regular pointer.

 Calloc()

void * calloc (size_t n, size_t size);    

The first argument specifies number of elements to be reserved. The second argument specifies the size in bytes of one element. The function returns a pointer to the beginning of the allocated storage area in memory It contents are cleared to zero before calloc returns

calloc function is used to reserve space for dynamic arrays.



Realloc()

Void* realloc(void *block, size_t size); 

 

First argument takes an existing block and try to reallocate it with the given size larger or smaller to the previous size. Second argument specifies the new size of the block. Realloc moves the old block bytes to new position in memory after reallocation. So the old pointer must also be changed with it.

 Free(void

*block)



Takes a pointer allocated by malloc and frees that block for later reuse.



After freeing a memory block it could not be accessed anymore

S.N.

Function and Description

1

void *calloc(int num, int size); This function allocates an array of num elements each of which size in bytes will be size.

3

void *malloc(int num); This function allocates an array of num bytes and leave them initialized.

4

void *realloc(void *address, int newsize); This function re-allocates memory extending it upto newsize.

2

void free(void *address); This function release a block of memory block specified by address.

 You

can define pointers to structures in very similar way as you define pointer to any other variable as follows: struct structure_name *pointer_name ;

This line declares that the pointer “pointer_name” will point to a datatype of “structure_name” Now this pointer contains garbage value and it can now be used to point to a defined type “structure_name”.

s1

struct student { int roll; char name[20]; float marks; }; Struct student s1; Struct student *ptr; Ptr=&s1;

name

state city

ptr

typedef struct Record { char name[21]; char city[21]; char state[3]; } Rec; Rec *r = (Rec *)malloc(sizeof(Rec)); name r

state city

typedef struct Record { int data; struct Record *link; } Rec; 20 5430 1000

Rec r1; Rec *ptr; 1000 ptr Ptr=&r1; 5430 Ptr->data=20; Ptr->link=(Rec *)malloc(sizeof(Rec));

THANK YOU