UNIT-4

POINTERS

INTRODUCTION:

POINTER:

A pointer is used to store the address of variable .

Declaration of pointer variable:

Syntax:

datatype *pointervariable;

Ex:

int *i;//integer pointer variable ‘i’ which stores address of integer variable.

float *b;// floating pointer variable ‘b’ which stores address of floating point variable.

char *ch;// character pointer variable ‘ch’ which stores address of character variable.

Initialization of pointer variable:

Syntax:

datatype *pointername;

pointername=&variablename;

Ex:

int *a,b=10; a b
2002 10
a=&b;

2000 2002

• In pointers we use 2 operators:

I.&-known as addressof operator or referencing operator-it is used to store address of
variable.
ii.*-known as dereferencing or valueat address of operator.

Example program for pointers:

#include<stdio.h>

#include<conio.h>
main()

{ a ptr

int a=10,*ptr; 10 1000

ptr=&a; 1000 1002

printf(“value of a is %d\n”,a);

printf(“value of a is %d\n”,*ptr);

printf(“value of a is %d\n”,*(&a));

printf(“value of a is %d\n”,*(*(&ptr)));

printf(“address of a is %u\n”,ptr);

printf(“address of a is %u\n”,&a);

printf(“address of ptr is %u\n”,&ptr);

getch();

Output:

value of a is 10

value of a is 10

value of a is 10

value of a is 10

address of a is 1000

address of a is 1000

address of ptr is 1002

Types of pointers:
1. NULL POINTER:

• A null pointer is a special pointer that doesn’t point to any value. This means that a
null pointer doesn’t point to any valid memory address.
• To declare a null pointer, you may use the predefined constant NULL,which is defined
in several standard header files including <stdio.h>,<stdlib.h> and <string.h>
 Ex: int *ptr=NULL;
• We can check whether a given pointer variable stores address of some variable or
contains a NULL string by writing
If(ptr==NULL)
{
Statement block;
}
• We may also initialize a pointer as a NULL pointer by using a constant 0,as shown
below:
int ptr;
ptr=0;
• Null pointers are used in situations where one of the pointers in the program points to
different locations at different times.
• 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.

2. GENERIC POINTER:

• A generic pointer is a pointer that has void as datatype.

• The void pointer or generic pointer is a special type of pointer that can be used to point
to variables of any data type.
• It is declared like a normal pointer variable but using the void keyword as the pointers
datatype.
Ex: void *ptr;
• In C,since you cannot have a variable of type void,the void pointer will therefore not
point to any data and thus cannot be dereferenced.
• You need to typecast a void pointer (Generic pointer) to another kind of pointer before
using it.
• Generic pointers are often used when you want a pointer to point to different datatypes
at different times.

Example program:

#include<stdio.h>

#include<conio.h>

main()

int x=10;

char ch=’a’;

float f=1.23;

void *gp;

gp=&x;
printf(“generic pointer points to the integer value=%d”,*(int *)gp);

gp=&ch;

printf(“generic pointer points to the character value=%c”,*(char *)gp);

gp=&f;

printf(“generic pointer points to the character value=%f”,*(float *)gp);

getch();

Output:

generic pointer points to the integer value=10

generic pointer points to the character value=a

generic pointer points to the character value=1.230000

POINTER TO POINTER:

• In this, by using one pointer, we will store the address of another pointer i.e.,
pointer stores the address of another pointer.

Declaring pointer to pointer:

Syntax:

datatype **pointervariable;

Example program for pointer to pointers:

#include<stdio.h>

#include<conio.h>

main()

{ a ptr1 ptr2 ptr3

10 1000 1002 1004
int a=10;

int *ptr1,**ptr2,***ptr3; 1000 1002 1004 1006

ptr1=&a;

ptr2=&ptr1;

ptr3=&ptr2;
 printf(“the value of a is %d\n”,a);

printf(“the value of ptr1 is %d\n”,*ptr1);

Printf(“the value of ptr2 is %u\n”,*ptr2);

Printf(“the value of ptr3 is %u\n”,*ptr3);

getch();

Output:

the value of a is 10

the value of ptr1 is 10

the value of ptr2 is 1000

the value of ptr3 is 1002

COMPATABILITY:

• You can assign an integer value to a double variable without using type conversion
in numeric types, but we cannot do the same to the pointers.
Example program:
#include<stdio.h>
#include<conio.h>
main()
{
int a=10;
double d=20.1234567;
int *ptr1,*ptr2;
ptr1=&a;
ptr2=&d;//error because ptr2 is integer pointer and ‘d’ is double value
printf(“the value of ptr1 is %u\n”,ptr1);
printf(“the value of ptr2 is %u\n”,ptr2);
getch();
}

L-VALUE AND R-VALUE :

• “l-value” refers to memory location which identifies an object. l-value may appear as
either left hand or right hand side of an assignment operator(=).
• l-value often represents as identifier.
• The name of the identifier denotes a storage location.
Operators that require L-value expression:
TYPE OF EXPRESSION EXAMPLES
Address operator &score
Postfix increment/decrement X++,y--
Prefix increment/decrement ++x,--y
Assignment(left operand) X=1,y+=3(y=y+3)

• “r-value” refers to data value that is stored at some address in memory.

• r-value can appear on right but not on left hand side of an assignment operator(=).
Invalid r-value Expressions:

EXPRESSION PROBLEM
A+2=6; A+2 is an r-value and cannot be the left
operand in an assignment. It is a
temporary value that doesn’t have an
address;no place to store 6
&(a+2) (a+2) is an r-valu,and the address
operator needs l-value.
&4; Same as above(4 is an r-value).

(a+2)++; Postfix and prefix operators require l-

++(a+2); values;(a+2) is an r-value.

II POINTER APPLICATIONS

POINTER TO ARRAYS:

• In pointer to array, the pointer stores address of the array. suppose we declare an
array x as follows:
int x[5]={6,0,2,5,1};
Then the elements will be stored as

Element-→ x[0] x[1] x[2] x[3] x[4]

Value→ 6 0 2 5 1

Address→ 2000 2002 2004 2006 2008

• Now if an integer pointer *ptr is declared and the address of 1st element is stored in
ptr,then
int *ptr;
ptr=&x[0];

Then,

ptr=&x[0]=2000;

ptr+1=&x[1]=2002;

ptr+2=&x[2]=2004;

ptr+3=&x[3]=2006;

ptr+4=&x[4]=2008;
so,

*(ptr+2)=x[2]=2;

Program to explain the concept of pointers in 1D array:

#include<stdio.h>

#include<conio.h>

main()

int x[5]={6,0,2,5,1};

int *ptr,i;

ptr=&x[0];//assigning base address to pointer

printf(“elements in array are:\n”);

for(i=0;i<5;i++)

printf(“%d stored at address %u”,*ptr,ptr);

ptr++;

getch();

Output:

Elements In array are:

6 stored at address 2000

0 stored at address 2002

2 stored at address 2004

5 stored at address 2006

1 stored at address 2008

POINTER AND 2D ARRAYS:

• Consider a 2D array ‘a’ with size of 2*2

int a[2][2]={{2,1},{3,4}};
• Then, the memory representation is as follows:

Row1 Row2

Values-→ 2 1 3 4
Index→
a[0][0] a[0][1] a[1][0] a[1][1]
Memory location 2000 2002 2004 2006
• Now if the base address of the array i.e., &a[0][0] is assigned to pointer ‘ptr’,then the 2D
array can be traversed by incrementing ‘ptr’ i.e.,
int *ptr;
ptr=&a[0][0];
ptr+1=&a[0][1];
ptr+2=&a[1][0];
ptr+3=&a[1][1];
Then *(&(a[0][1]))=1
Program to explain the concept of pointers and 2D arrays:
#include<stdio.h>
#include<conio.h>
main()
{
int a[2][2]={{2,1},{3,4}};
int *ptr,i,j;
printf(“elements of 2d array are:\n”);
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
{
printf(“%d\t”,*ptr);
ptr++;
}
printf(“\n”);
}
}
POINTER ARITHMETIC:
The arithmetic operations that we can perform on pointers are:
1. Incrementation of pointers
2. Decrementation of pointers
3. Adding a number to pointer
4. Subtracting a number from pointer
5. Subtracting two pointer variables

Invalid pointer arithmetic operators are:

 1. Addition of two pointer variables
2. Multiplication of two pointer variables
3. Division of two pointer variables
4. Modulo operation of two pointer variables

Program to demonstrate pointer arithmetic:

#include<stdio.h>

#include<conio.h>

main()

int *ptr1,*ptr2;

int a[5]={10,20,30,40,50};

ptr1=&a[0];

printf(“initially the ptr1 value is %u\n”,ptr1);

ptr1++;

printf(“after incrementing the ptr1 value is %u\n”,ptr1);

ptr2=&a[4];

printf(“initially the ptr2 value is %u\n”,ptr2);

ptr2--;

printf(“after decrementing the ptr2 value is %u\n”,ptr2);

ptr1=ptr1+2;

printf(“the ptr1 value is %u\n”,ptr1);

ptr2=ptr2-2;

printf(“the ptr2 value is %u\n”,ptr2);

getch();

ARRAY OF POINTERS:

Array of pointers stores the collection of addresses.

Syntax:

datatype *arrayname[size];
Ex: int *a[10];//by using this, we can store 10 addresses of integer values.

float *c[5];//by using this, we can store 5 addresses of floating point values.

char *d[5];//by using this,we can store 5 addresses of character values.

Program to demonstrate array of pointers:

#include<stdio.h>

#include<conio.h>

main()

int a=10,b=20,c=30; a 10 b 20 c 30

int *ptr[10]; 1000 2002 3032

clrscr(); ptr

ptr[0]=&a;

ptr[1]=&b; ptr[0] ptr[1] ptr[2] ptr[3] ptr[4] ptr[5] ptr[6] ptr[7] ptr[8] ptr[9]

ptr[2]=&c; 4000 4002 4004 4006 4008 4010 4012 4014 4016 4018

printf(“the address of a is %u\n”,ptr[0]);

printf(“the value of a is %d\n”,*ptr[0]);

printf(“the address of b is %u\n”,ptr[1]);

printf(“the value of b is %d\n”,*ptr[1]);

printf(“the address of c is %u\n”,ptr[2]);

printf(“the value of c is %d\n”,*ptr[2]);

getch();

MEMORY ALLOCATION:

There are 2 ways to allocate memory to the variables.

1. Static memory allocation

2. Dynamic memory allocation

Static memory allocation:

In this memory allocation,the memory is allocated at compile time.

Disadvantages:

1.Arrays use static memory allocation.

Ex: int a[5];we can store 5 elements

2.once memory is allocated, it is not possible to change the size of the array.

3.if more memory is allocated than required, the memory is wasted.

Ex: int a[100];if we the memory to store 5 elements then remaining memory is wasted.

4.if less memory is allocated than the required, we can’t store more elements.

Ex: int a[5];cant store more than 5 elements.

Dynamic memory allocation:

• To overcome the limitations of static memory allocation, dynamic memory allocation is

used.
• The memory which is allocated during execution/runtime.
• To implement dynamic memory allocation, we have 4 functions:
1. Malloc
2. Calloc
3. Realloc
4. Free

Memory allocation(malloc):

• Malloc is mainly used to allocate memory to a pointer variable during execution time.
• It allocates requested size in terms of bytes and returns pointer to the starting address
of the memory block.
• Malloc allocates only one block of memory.
Syntax:
datatype *pointervariable=(datatype *)malloc(type size);
Ex: int *ptr=(int *)malloc(n*sizeof(2));
If the number of elements are 5 then 10 bytes of memory is allocated for pointer
variable ptr.
• Malloc function accepts only one argument i.e., byte size.
• The default initial values are garbage values.

C program to demonstrate malloc function:

#include<stdio.h>

#include<string.h>

main()
{

int i,n;

int *ptr;

printf("enter the size of array\n");

scanf("%d",&n);

ptr=(int *)malloc(n*sizeof(int));

printf("enter the elements of array\n");

for(i=0;i<n;i++)

scanf("%d",&ptr[i]);

printf("the values of array are\n");

for(i=0;i<n;i++)

printf("%d\t",ptr[i]);

Output:

enter the size of array

enter the elements of array

10 20 30 40 50

the values of array are

10 20 30 40 50

Example program:(Allocating Memory for structures using Malloc )

#include<stdio.h>

#include<stdlib.h>
main()

struct student

int rno;

float per;

};

struct student *ptr;

ptr=(struct student*)malloc(sizeof(struct student));

if(ptr==NULL)

printf("memory not allocated\n");

else

printf("enter the student details\n");

printf("enter the roll number\n");

scanf("%d",&ptr->rno);

printf("enter the percentage\n");

scanf("%f",&ptr->per);

printf("roll number of student is %d\n",ptr->rno);

printf("percentage of student is %f\n",ptr->per);

Output:

enter the student details

enter the roll number

10

enter the percentage

98

roll number of student is 10

percentage of student is 98

CONTIGUOUS ALLOCATION(CALLOC):

• calloc is useful to allocate memory to a pointer variable during execution time.

• It allocates multiple blocks of memory and returns pointer to the starting block/first
block.
Syntax:
Datatype *pointer=(datatype *)calloc(number of blocks,size of block);
Ex: int *ptr=(int *)calloc(5,2);
• calloc function requires 2 arguments
• Default initial values are zero.

C program to demonstrate calloc function:

#include<stdio.h>

main()

int i,n;

int *ptr;

printf("enter the size of array\n");

scanf("%d",&n);

ptr=(int *)calloc(n,sizeof(int));

printf("eneter the eleemnts of array\n");

for(i=0;i<n;i++)

scanf("%d",&ptr[i]);
 }

printf("the values of array are\n");

for(i=0;i<n;i++)

printf("%d\t",ptr[i]);

Output:

enter the size of array

enter the elements of array

10 20 30 40 50

the values of array are

10 20 30 40 50

REALLOC FUNCTION:

• It is used to modify the size of the allocated memory.

Syntax:

realloc(pointervariable,bytesize);

C program to demonstrate realloc function:

#include<stdio.h>

#include<stdlib.h>

main()

char *str;

str=(char *)malloc(5);
 if(str==NULL)

printf("Memory not allocated\n");

strcpy(str,"hell");

printf("the string is %s\n",str);

str=(char *)realloc(str,20);

if(str==NULL)

printf("Memory not allocated\n");

strcpy(str,"hello world ");

printf("the string is %s\n",str);

Output:

The string is hell

The string is hello world

Free:

• Free function frees the memory allocated by malloc and calloc functions.