CE141: COMPUTER CONCEPTS & PROGRAMMING

Chapter – 11

Pointers

Devang Patel Institute of Advance Technology and Research

Objectives
 To be able to know the concepts of Pointers
 To be able to know how pointer variables are used in a
program
 To be able to explain the chain of pointers
 To be able to know the Pointer Expression
 To be able to describe Pointers and Arrays

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Introduction
 In this chapter, we will discuss
 Understanding Pointers

 Underlying Concepts of Pointers

 Accessing the concepts of a variable

 Declaring Pointer Variable

 Initialization of Pointer Variable

 Accessing a Variable through its Pointer

 Chain of Pointers

 Pointer Expression

 Pointer increments and scale factor

 Pointers and character string

 Array of Pointers

 Pointers as Function Arguments

 Function Returning Pointers

 Pointers to Function

 Pointers and Structures

 Trouble with Pointers

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Understanding Pointers
 The computer memory is the sequential collection of
storage cells
 Each cell known as byte, has a number called address
associated with it.
 Address starts from zero. Last address depends on
memory size.
 Computer having 64K memory will have its last address
65,535.
 At the declaration time systems allocates, some
appropriate location to hold the value of the variable

Variables that hold memory addresses are called pointer variables.

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Introduction
 Pointers are variables that contain memory addresses as their
values.
 A variable name directly references a value.
 A pointer indirectly references a value. Referencing a value
through a pointer is called indirection.
 A pointer variable must be declared before it can be used.

Memory address: 1020 1024 1032

… … 100 … 1024 …
intege pointer
r
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Introduction

Memory Cell Address

0

. Variable: x
65,535
Value: 7
Address: 1000
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Underlying Concepts of Pointers
• Memory address within the computer
• We can not change them
• We can only use them to store data
values
Pointer
Pointers

Constants • Can’t save the value of memory

address directly
• Can only obtain the value
Pointer Values through the variable stored there
using the address operator (&)

• Once we have a pointer value, it

Pointer Variables can be stored into another
variable
• The variable that contains a
pointer value is called as pointer
variable.

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Accessing the concepts of a variable
 Actual location of a variable is system dependent

 & immediately proceeding a variable returns the address of the

variable. For example, p=&a.

 & operator can be used with simple variable or array element.

 Following are illegal use:

 &125 (Pointing at constants)

 int x[10];

&x (Pointing at array names)

 &(x+y) (Pointing at expression)

 If x is an array, then expression such as &x[0] and x[i+3]

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Accessing the concepts of a variable
#include<stdio.h>
#include<conio.h>
void main()
{
char a='A';
int b=5;
float c=10.2, d=11.544;
clrscr();

printf("a=%c &a=%u\n",a,&a);
printf("b=%d &b=%u\n",b,&b);
printf("c=%f &c=%u\n",c,&c);
printf("d=%f &d=%u\n",d,&d);

getch();
}
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Declaring Pointer Variable
 In c, variable must be declared.
data_type *pt_name;
This tells the compiler three things about the variable pt_name.
 * tells that pt_name is pointer variable
 pt_name needs memory location.

 pt_name points to a variable of type data-type.

For example, int *a; /* integer pointer */

 Declares the variable a as a pointer variable that points to an
integer datatype.

The type int refers to the data type of the variable

being pointed to by a and not the type of the value of
the pointer

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Declaring Pointer Variable- Pointer
declaration style
 Pointers variables are declared similarly as normal
variables except for the addition of the unary operator.

int* p; int *p;

Style-1 Style-2
int *p, x,*q; int x, *p, y;
x=10;
p=&x;
y=*p; /*Accessing x through p */
*p=20; /*Accessing 20 to x */

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Initialization of Pointer Variable
 Process of assigning the address of a variable to a pointer
variable is known as initialization

 Once pointer variable has been declared we can use the

assignment operator to initialize the variable

int quantity;

int *p; /*declaration*/

p=&quantity; /*initialization*/

or

int *p=&quantity

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Initialization of Pointer Variable
 Pointer variables always point to the corresponding type of data

 For example,

float a,b;

int x,*p;

p=&a; /*Wrong*/

b=*p;

Will result in erroneous output because we are trying to assign the address of
a float variable to an integer pointer

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Initialization of Pointer Variable
 We could define a pointer variable with an initial
value of NULL or 0.
int *p=NULL;
int *p=0;
 With the exception of NULL and 0, no other
constant value can be assigned to a pointer
variable.
 For example, following is wrong:
int *p=5360; /*absolute address */

– 12 :User-Defined
ChapterChapter – 11: Pointers’
Functions
Initialization of Pointer Variable- Pointer Flexibility
 Same Pointer to different data variables in different
statement.
int x,y,z,*p; X Y Z
………….
p=&x;
………….
p=&x;
…………. P
p=&z;
………….
 Different Pointers to point to the same data variable.
int x;
X Y Z
int *p1=&x;
int *p2=&x;
int *p3=&x;
……………….. P
………………..

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Accessing a variable through its
Pointer
 How to access the value of a variable using
pointer?
int q,*p, n; //Declaration of q, n and pointer p
q=10; //Initialization of q
p=&q // Initialization of the address of the p
n=*p; //returns the value of a variable of which
address is stored

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
void main()
{
int x,y;
int *p;
x=10;
p=&x;
y=*p;
clrscr();
printf("Value of x is %d\n\n", x);
printf("%d is stored at address %u\n",x, &x);
printf("%d is stored at address %u\n", *&x, &x);
printf("%d is stored at address %u\n", *p, p);
printf("%u is stored at address %u\n", p, &p);
printf("%d is stored at address %u\n", y, &y);
*p=25;
printf("\nNow x=%d\n", x);
getch();
}

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 x y p
Declaration
65524 65522 65520 Address

X=10 10
65524 65522 65520 Address
p=&x 10 65524
65524 65522 65520 Address

y=*p 10 10 65524

65524 65522 65520 Address

Pointer to x

*p=25 25 10 65524 Address

65524 65522 65520

Illustration of Pointer Assignments

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Chain of Pointers
 Possible to make a pointer to another pointer, thus
creating a chain of pointer as shown
Address 2 Address 1 Value

p2 p1 Variable
 Pointer p2 contains the address of pointer variable
p1, which points to the location that contains the
desired value
 Declaration of Pointer to Pointer: int **p2

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
void main()
{
int x,y;
int *p,**z;
x=10;
p=&x;
y=*p;
z=&p;
clrscr();
printf("Value of x is %d\n\n",x);
printf("x=%d is stored at address &x=%u\n",x,&x);
printf("*&x=%d is stored at address &x=%u\n",*&x,&x);
printf("*p=%d is stored at address p=%u\n",*p,p);
printf("p=%u is stored at address &p=%u\n",p,&p);
printf("y=%d is stored at address &y=%u\n",y,&y);
*p=25;
printf("\nNow x=%d\n",x);
printf("z=%u is stored at address &z=%u\n **z=%u",z,&z,**z);
getch();
}
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointer Expressions

 Pointer variables can be used in expressions

 For example, p1 and p2 are declared and
initialized pointer variables, then
Y=*p1+*p2
X=(*p1)*(*p2)
p1*p2\\invalid

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointer Increments and Scale Factor

 Pointers can be incremented like

p1=p1+1 or p1++

 If p1 is an int pointer with initial value , say

2800,then after the operation p1=p1+1, the
value of p1 will 2802, not 2801

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
void main()
{
int x=10,y=5,sum,sum1;
int *p,*q;

p=&x;
q=&y;
clrscr();
sum=*p+*q;
printf("sum=%d",sum);
printf("\np=%u q=%u",p,q);
//invalid pointer addition sum1=p+q;
*p=*p+2;
++*q;
printf("\nx=%d *p=%d *q=%d\np=%u q=%u",x,*p,*q,p,q);
getch();
}

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers and Arrays
 When an array is declared, the compiler allocates a base
address and sufficient amount storage to contain all the
array in contiguous memory location.
 The base address is the location of the first element (index
0) of the array

X[0] X[1] X[2] X[3] X[4]

1 2 3 4 5

1000 1002 1004 1006 1008

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
void main()
{
int *p,sum=0,i=0;
int x[5]={1,2,3,4,5};
p=x;
clrscr();
printf("\tElement\tvalue\tAddress\n");
while(i<5)
{
printf("\tx[%d]\t%d\t%u\n",i,*p,p);
sum=sum+*p;
i++,p++;
}
printf("sum=%d\n",sum);
printf("&x[0]=%u\n",&x[0]);
printf("p=%u\n",p) ;
getch();
If we remove p++ from the
} while loop then following
output will be generated

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers and Arrays
 We can access every value of x using p++ to move
one element to another.
 The relationship between p and x is shown as:

 P=&x[0] (=65514)
 P+1=&x[1] (=65516)
 P+2=&x[2] (=65518)
 P+3=&x[3] (=65520)
 P+4=&x[4] (=65522)

 Address of element is calculated as:

Address of x[3]=65514+(3*2)=65520
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers and Arrays

 Pointers can be used to manipulate two-D

arrays as well

 In one-D array x, the expression

 *(x+i) or *(p+i)

 Two-D array can be represented by

 *(*(a+i)+j) or *(*(p+i)j)
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers in 2-D Array
Columns
0 1 2 3 4 5

0 P
1 P+1
2
Rows 3
4 4,0 4,3 P+4
5
6 P+6
*(P+4) *(P+4)+3
P Pointer to the First Row
p+i Pointer to the ith Row
*(p+i) Pointer to first element in the ith Row

*(p+i)+j Pointer to jth element in the ith Row

*(*(p+i)+j) Value stored in the cell (i,j)

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers and Character strings

 C provides alternative method to create

strings by using pointer variables of type
char.
 char *str=“good”

g o o d \0

str

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers and Character strings

 To print the content of the string1

char *string1;

pritntf(“%s”, string1); or

puts(string1);

 Although string1 is a pointer to the string, it is also the

name of the string.

 There for we do not need to use indirect operator *.

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers and Character strings
void main()
{
char *name="DELHI";
char *p=name;

clrscr();
printf("%s",name);

while(*p!='\0')
{
printf("\n%c is stored at %u\n",*p,p);
p++;
}
getch();
}
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Array of Pointers
 Important use of pointer: To handle table of String
 char name [3][25];
 Following is the table named “name” which contains 3
names, each with a maximum length of 25 characters
(including null character).
Name[0]
Name[1]
Name[2]

char *name[3]={
“New Zealand”, N E W Z E A L A N D \
0 Name[0]
“Australia”, A U S T R A L I A \
Name[1]
“India”
0

I N D I A \ Name[2]
} 0

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Array of Pointers
 The following statement would print out all three names

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

printf(“%s \n”, name[i]);

 To access jth character in the ith name, we may write as

*(name[i]+j)

 The character arrays with the rows of varying length called

“Ragged Arrays”

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Array of Pointers

Difference between *p[3] and (*p)[3]

 Since * has a lower precedence than [], *p[3]

declares p as an array of 3 pointers

 (*p)[3] declares p as a pointer to an array of

3 elements

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Pointers as Function Arguments

 The address should pass to the function as an argument

 The parameters receiving the address should be pointers

 The process of calling a function using pointers to pass the

address of variables is known as call by reference.

 The process of passing actual value of variables is known as call

by value.

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
int swap(int*,int*);
void main()
{
int x,y;
x=100;
y=200;
printf("Before Exchange: x=%d y=%d\n\n",x,y);
swap(&x,&y);
printf("After Exchange: x=%d y=%d\n\n",x,y);
getch();
}

int swap (int *a,int *b)

{
int t;
t=*a;
*a=*b;
*b=t;
}
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Pointers as Function Arguments

Note:
 The function parameters are declared as pointers

 The dereferenced pointers are use in the function

body

 When the function is called, the addresses are

passed as actual arguments

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Function Returning Pointers

 Function can return multiple values through

pointer parameters

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
*large();
void main()
{
int x=10,y=5,*p;
clrscr();
p=large(&x,&y);
printf("%d",*p);

getch();
}
*large(int *a,int *b)
{
if(*a>*b)
return(a);
else
return(b);
}

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Pointer to Function
 A function, like a variable, has a type and address location in the memory.

 It is therefore, possible to declare a pointer to a function

 We can make a function pointer to point a specific function by simply assigning

the name of the of the function to the pointer

 For example
double mul (int , int);

double (*p1)();

p1=mul;

 To call mul, we may now use the pointer p1 with the list of parameters

(*p1)(x,y);/*Function call*/ is equivalent to

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Compatibility and Casting
int x;
char *p;
p=(char *) &x;

Casting

When the variable datatype and pointer variable data

type is different then casting is necessary

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Compatibility and Casting
Void pointer:

 It is generic pointer

 All the types can be assigned to void pointer without casting.

 For example

int x;

char y;

void *v;

v=&x;

v=&y;

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Pointers and Structures
struct inventory

char name[30];

int number;

float price;

}product[2], ptr*;

product: Data object, array of two elements, each of the type strut inventory

ptr: pointer to data object of struct inventory

ptr=product ;\\assignment

Would assign the address of 0th element of product to ptr.

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
 Pointers and Structures
 The pointer ptr will now point to product[0].

 Members can accessed by:

ptr->name
Selection Operator
ptr->number

ptr->price

Or (*ptr).number

for(ptr=product; ptr<product+2; p++)

printf(“%s %d %f \n”,ptr->name, ptr->number, ptr-
>price);

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Troubles with pointers
 Assigning values to uninitialized pointers
int *p, m=100;
*p=m; /*Error*/
 Assigning value to a pointer variable

int *p,m=100;
p=m; /*Error*/
 Not dereferencing a pointer when required

int *p,x=100;
p=&x;
printf(“%d”,p); /*Error*/
 Assigning the address of an uninitialized variable

int m,*p;
p=&m;
Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Previous year questions
 Differentiate: Call by value and Call by
reference [5 marks]
 Write a program which adds two integer
numbers using pointers only [3 marks]
 State true/false: Pointers reduce the length
and complexity of a program [1 mark]
 What do you mean by pointer? Explain
advantage and disadvantage of pointer?

Chapter – 11 : Pointers’
Previous year questions

 Write the output of the code: [1 marks]

#include<stdio.h>
void main(){
int i=3;
int *j;
int **k;
j=&i;
k=&j;
printf(“%d”,*(&i));
printf(“%d”,**k);
}

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Previous year questions

 Check following C code. Find runtime error

if any. Also discuss advantages of pointer to
function. [4 marks]
int *function(){
int x=10;
return(&x);
}
void main(){
printf(“%d”,*(function()));
}

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions
Previous year questions

 Define pointer. How we can access any

variable through its pointer?[2 marks]
 Write a program using pointers to compute
the sum of all elements stored in an array of
size 5. [4 marks]
 State ture/false: Pointer is a variable that
stores the address of the another variable.
[1 mark]

Chapter – 12 :User-Defined
Chapter – 11 : Pointers’
Functions