Pointers in C

Spring Semester 2011 Programming and Data Structure 1

 Introduction

• A pointer is a variable that represents the

location (rather than the value) of a data item.
• They have a number of useful applications.
– Enables us to access a variable that is defined
outside the function.
– Can be used to pass information back and forth
between a function and its reference point.
– More efficient in handling data tables.
– Reduces the length and complexity of a program.
– Sometimes also increases the execution speed.

Spring Semester 2011 Programming and Data Structure 2

 Basic Concept

• In memory, every stored data item occupies

one or more contiguous memory cells
(bytes).
– The number of bytes required to store a data item
depends on its type (char, int, float, double, etc.).
• Whenever we declare a variable, the system
allocates memory location(s) to hold the
value of the variable.
– Since every byte in memory has a unique address,
this location will also have its own (unique)
address.
Spring Semester 2011 Programming and Data Structure 3
 Contd.

• Consider the statement

int xyz = 50;
– This statement instructs the compiler to
allocate a location for the integer variable xyz,
and put the value 50 in that location.
– Suppose that the address location chosen is
1380.
xyz
variable
50
value
1380
address

Spring Semester 2011 Programming and Data Structure 4

 Contd.
• During execution of the program, the
system always associates the name xyz
with the address 1380.
– The value 50 can be accessed by using either
the name xyz or the address 1380.
• Since memory addresses are simply
numbers, they can be assigned to some
variables which can be stored in memory.
– Such variables that hold memory addresses
are called pointers.
– Since a pointer is a variable, its value is also
stored in some memory location.
Spring Semester 2011 Programming and Data Structure 5
 Contd.

• Suppose we assign the address of xyz to

a “pointer” variable p.
– p is said to point to the variable xyz.

Variable Value Address

xyz 50 1380 p = &xyz;
p 1380 2545

Spring Semester 2011 Programming and Data Structure 6

 Accessing the Address of a Variable
• The address of a variable can be determined
using the ‘&’ operator.
– The operator ‘&’ immediately preceding a variable
returns the address of the variable.
• Example:
p = &xyz;
– The address of xyz (1380) is assigned to p.
• The ‘&’ operator can be used only with a
simple variable or an array element.
&distance
&x[0]
&x[i-2]
Spring Semester 2011 Programming and Data Structure 7
 Contd.

• Following usages are illegal:

&235 -- Pointing at a constant.

int arr[20];
:
&arr; -- Pointing at array name.

&(a+b) -- Pointing at expression.

Spring Semester 2011 Programming and Data Structure 8

 Example
#include <stdio.h>
main()
{
int a;
float b, c;
double d;
char ch;

a = 10; b = 2.5; c = 12.36; d = 12345.66; ch = ’A’;

printf (”%d is stored in location %u \n”, a, &a) ;
printf (”%f is stored in location %u \n”, b, &b) ;
printf (”%f is stored in location %u \n”, c, &c) ;
printf (”%ld is stored in location %u \n”, d, &d) ;
printf (”%c is stored in location %u \n”, ch, &ch) ;
}

Spring Semester 2011 Programming and Data Structure 9

Output:

10 is stored in location 3221224908

2.500000 is stored in location 3221224904
12.360000 is stored in location 3221224900
12345.660000 is stored in location 3221224892
A is stored in location 3221224891

Spring Semester 2011 Programming and Data Structure 10

 Pointer Declarations
• Pointer variables must be declared before
we use them.
• General form:
data_type *pointer_name;
• Three things are specified in the above
declaration:
• The asterisk (*) tells that the variable
pointer_name is a pointer variable.
• pointer_name needs a memory location.
• pointer_name points to a variable of type
data_type.
Spring Semester 2011 Programming and Data Structure 11
 Contd.

• Example:
int *count;
float *speed;
• Once a pointer variable has been declared,
it can be made to point to a variable using
an assignment statement like:
int *p, xyz;
:
p = &xyz;
– This is called pointer initialization.

Spring Semester 2011 Programming and Data Structure 12

 Things to Remember

• Pointer variables must always point to a data item of

the same type.
float x;
int *p;
:
will result in erroneous output
p = &x;
• Assigning an absolute address to a pointer variable
is prohibited.
int *count;
:
count = 1268;

Spring Semester 2011 Programming and Data Structure 13

 Accessing a Variable Through its
Pointer
• Once a pointer has been assigned the address of
a variable, the value of the variable can be
accessed using the indirection operator (*).

int a, b;
int *p; b = a;
Equivalent to
:
p = &a;
b = *p;

Spring Semester 2011 Programming and Data Structure 14

 Example 1
#include <stdio.h>
main()
{ Equivalent
int a, b;
int c = 5;
int *p;

a = 4 * (c + 5) ;

p = &c;
b = 4 * (*p + 5) ;
printf (”a=%d b=%d \n”, a, b);
} a=40 b=40

Spring Semester 2011 Programming and Data Structure 15

 Example 2
#include <stdio.h>
main()
{
int x, y;
int *ptr;

x = 10 ;
ptr = &x ;
y = *ptr ;
printf (”%d is stored in location %u \n”, x, &x) ;
printf (”%d is stored in location %u \n”, *&x, &x) ;
printf (”%d is stored in location %u \n”, *ptr, ptr) ;
printf (“%d is stored in location %u \n”, y, &*ptr) ;
printf (“%u is stored in location %u \n”, ptr, &ptr) ;
printf (“%d is stored in location %u \n”, y, &y) ;

*ptr = 25;
printf (”\nNow x = %d \n”, x);
}

Spring Semester 2011 Programming and Data Structure 16

 Address of x: 3221224908
Address of y: 3221224904
Address of ptr: 3221224900

Output:

10 is stored in location 3221224908

10 is stored in location 3221224908
10 is stored in location 3221224908
10 is stored in location 3221224908
3221224908 is stored in location 3221224900
10 is stored in location 3221224904

Now x = 25

Spring Semester 2011 Programming and Data Structure 17

 Pointer Expressions

• Like other variables, pointer variables can

be used in expressions.
• If p1 and p2 are two pointers, the following
statements are valid:
sum = *p1 + *p2;
prod = *p1 * *p2;
prod = (*p1) * (*p2);
*p1 = *p1 + 2; *p1 can appear on
the left hand side
x = *p1 / *p2 + 5;

Spring Semester 2011 Programming and Data Structure 18

 Contd.

• What are allowed in C?

– Add an integer to a pointer.
– Subtract an integer from a pointer.
– Subtract one pointer from another (related).
• If p1 and p2 are both pointers to the same
array, then p2–p1 gives the number of
elements between p1 and p2.

Spring Semester 2011 Programming and Data Structure 19

• What are not allowed?
– Add two pointers.
p1 = p1 + p2;

– Multiply / divide a pointer in an expression.

p1 = p2 / 5;
p1 = p1 – p2 * 10;

Spring Semester 2011 Programming and Data Structure 20

 Scale Factor

• We have seen that an integer value can be added

to or subtracted from a pointer variable.

int *p1, *p2;

int i, j;
:
p1 = p1 + 1;
p2 = p1 + j;
p2++;
p2 = p2 – (i + j);

– In reality, it is not the integer value which is

added/subtracted, but rather the scale factor
times the value.
Spring Semester 2011 Programming and Data Structure 21
 Contd.

Data Type Scale Factor

char 1
int 4
float 4
double 8

– If p1 is an integer pointer, then

p1++
will increment the value of p1 by 4.

Spring Semester 2011 Programming and Data Structure 22

• Note:
– The exact scale factor may vary from one
machine to another.
– Can be found out using the sizeof function.
– Syntax:
sizeof (data_type)

Spring Semester 2011 Programming and Data Structure 23

 Example: to find the scale factors
#include <stdio.h>
main()
{
printf (”No. of bytes occupied by int is %d \n”, sizeof(int));
printf (”No. of bytes occupied by float is %d \n”, sizeof(float));
printf (”No. of bytes occupied by double is %d \n”, sizeof(double));
printf (”No. of bytes occupied by char is %d \n”, sizeof(char));
}

Output:

Number of bytes occupied by int is 4

Number of bytes occupied by float is 4
Number of bytes occupied by double is 8
Number of bytes occupied by char is 1

Spring Semester 2011 Programming and Data Structure 24

 Passing Pointers to a Function
• Pointers are often passed to a function as
arguments.
– Allows data items within the calling program to
be accessed by the function, altered, and then
returned to the calling program in altered form.
– Called call-by-reference (or by address or by
location).
• Normally, arguments are passed to a
function by value.
– The data items are copied to the function.
– Changes are not reflected in the calling program.

Spring Semester 2011 Programming and Data Structure 25

 Example: passing arguments by value
#include <stdio.h>
main()
{
int a, b;
a = 5; b = 20;
swap (a, b); Output
printf (“\n a=%d, b=%d”, a, b);
} a=5, b=20

void swap (int x, int y)

{
int t;
t = x;
x = y;
y = t;
}

Spring Semester 2011 Programming and Data Structure 26

 Example: passing arguments by
reference
#include <stdio.h>
main()
{
int a, b;
a = 5; b = 20;
swap (&a, &b); Output
printf (“\n a=%d, b=%d”, a, b);
} a=20, b=5

void swap (int *x, int *y)

{
int t;
t = *x;
*x = *y;
*y = t;
}

Spring Semester 2011 Programming and Data Structure 27

 scanf Revisited

int x, y;
printf (”%d %d %d”, x, y, x+y);

• What about scanf ?

scanf (”%d %d %d”, x, y, x+y) ; NO

scanf (”%d %d”, &x, &y) ; YES

Spring Semester 2011 Programming and Data Structure 28

 Example: Sort 3 integers

Three-step algorithm:
1. Read in three integers x, y and z
2. Put smallest in x
• Swap x, y if necessary; then swap x, z if necessary.
3. Put second smallest in y
• Swap y, z if necessary.

Spring Semester 2011 Programming and Data Structure 29

 Contd.

#include <stdio.h>
main()
{
int x, y, z;
………
scanf (”%d %d %d”, &x, &y, &z);
if (x > y) swap(&x,&y);
if (x > z) swap(&x,&z);
if (y > z) swap(&y,&z);
………
}

Spring Semester 2011 Programming and Data Structure 30

 sort3 as a function
#include <stdio.h>
main()
{
int x, y, z;
………
scanf (”%d %d %d”, &x, &y, &z);
sort3 (&x, &y, &z);
………
}

void sort3 (int *xp, int *yp, int *zp)

{
if (*xp > *yp) swap (xp, yp);
if (*xp > *zp) swap (xp, zp);
if (*yp > *zp) swap (yp, zp);
}

Spring Semester 2011 Programming and Data Structure 31

 Contd.

• Why no ‘&’ in swap call?

– Because xp, yp and zp are already pointers
that point to the variables that we want to
swap.

Spring Semester 2011 Programming and Data Structure 32

 Pointers and Arrays

• When an array is declared,

– The compiler allocates a base address and
sufficient amount of storage to contain all the
elements of the array in contiguous memory
locations.
– The base address is the location of the first
element (index 0) of the array.
– The compiler also defines the array name as a
constant pointer to the first element.

Spring Semester 2011 Programming and Data Structure 33

 Example
• Consider the declaration:
int x[5] = {1, 2, 3, 4, 5};

– Suppose that the base address of x is 2500,

and each integer requires 4 bytes.
Element Value Address
x[0] 1 2500
x[1] 2 2504
x[2] 3 2508
x[3] 4 2512
x[4] 5 2516

Spring Semester 2011 Programming and Data Structure 34

 Contd.

Both x and &x[0] have the value 2500.

p = x; and p = &x[0]; are equivalent.

– We can access successive values of x by
using p++ or p-- to move from one element to
another.
• Relationship between p and x:
p = &x[0] = 2500
p+1 = &x[1] = 2504
*(p+i) gives the
p+2 = &x[2] = 2508
value of x[i]
p+3 = &x[3] = 2512
p+4 = &x[4] = 2516

Spring Semester 2011 Programming and Data Structure 35

 Example: function to find average

#include <stdio.h> float avg (array, size)

main() int array[], size;
{ {
int x[100], k, n; int *p, i , sum = 0;

scanf (”%d”, &n); p = array;

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

scanf (”%d”, &x[k]); sum = sum + *(p+i);

printf (”\nAverage is %f”, return ((float) sum / size);

avg (x, n)); }
}

Spring Semester 2011 Programming and Data Structure 36

 Example with 2-D array

TO BE DISCUSSED LATER

Spring Semester 2011 Programming and Data Structure 37

 Structures Revisited

• Recall that a structure can be declared as:

struct stud {
int roll;
char dept_code[25];
float cgpa;
};
struct stud a, b, c;

• And the individual structure elements can

be accessed as:
a.roll , b.roll , c.cgpa

Spring Semester 2011 Programming and Data Structure 38

 Arrays of Structures

• We can define an array of structure

records as
struct stud class[100];

• The structure elements of the individual

records can be accessed as:
class[i].roll
class[20].dept_code
class[k++].cgpa

Spring Semester 2011 Programming and Data Structure 39

 Example :: sort by roll number (bubble sort)
#include <stdio.h> for (k=0; k<n; k++)
struct stud scanf (”%d %s %f”, &class[k].roll,
{ class[k].dept_code,
int roll; &class[k].cgpa);
char dept_code[25]; for (j=0; j<n-1; j++)
float cgpa; for (k=1; k<n-j; k++)
}; {
if (class[k-1].roll >
main() class[k].roll)
{ {
struc stud class[100], t; t = class[k-1];
int j, k, n; class[k-1] = class[k];
class[k] = t;
scanf (”%d”, &n); }
/* no. of students */ }
<<<< PRINT THE RECORDS >>>>
}

Spring Semester 2011 Programming and Data Structure 40

 Example :: selection sort
int min_loc (struct stud x[],
int k, int size) int selsort (struct stud x[],int n)
int j, pos;
{
{
int k, m;
pos = k;
for (k=0; k<n-1; k++)
for (j=k+1; j<size; j++)
{
if (x[j] < x[pos])
m = min_loc (x, k, n);
pos = j;
temp = a[k];
return pos;
a[k] = a[m];
}
a[m] = temp;
}
main() }
{
struc stud class[100];
int n;
…
selsort (class, n);
…
Spring Semester 2011 Programming and Data Structure 41
 Arrays within Structures
• C allows the use of arrays as structure members.
• Example:
struct stud {
int roll;
char dept_code[25];
int marks[6];
float cgpa;
};
struct stud class[100];

• To access individual marks of students:

class[35].marks[4]
class[i].marks[j]

Spring Semester 2011 Programming and Data Structure 42

 Pointers and Structures

• You may recall that the name of an array

stands for the address of its zero-th
element.
– Also true for the names of arrays of structure
variables.

• Consider the declaration:

struct stud {
int roll;
char dept_code[25];
float cgpa;
} class[100], *ptr ;

Spring Semester 2011 Programming and Data Structure 43

 – The name class represents the address of the
zero-th element of the structure array.
– ptr is a pointer to data objects of the type
struct stud.
• The assignment
ptr = class;
will assign the address of class[0] to ptr.
• When the pointer ptr is incremented by one
(ptr++) :
– The value of ptr is actually increased by
sizeof(stud).
– It is made to point to the next record.
Spring Semester 2011 Programming and Data Structure 44
• Once ptr points to a structure variable, the
members can be accessed as:
ptr –> roll;
ptr –> dept_code;
ptr –> cgpa;

– The symbol “–>” is called the arrow operator.

Spring Semester 2011 Programming and Data Structure 45

 A Warning

• When using structure pointers, we should

take care of operator precedence.
– Member operator “.” has higher precedence than
“*”.
ptr –> roll and (*ptr).roll mean the
same thing.
*ptr.roll will lead to error.

– The operator “–>” enjoys the highest priority

among operators.
++ptr –> roll will increment roll, not ptr.
(++ptr) –> roll will do the intended thing.

Spring Semester 2011 Programming and Data Structure 46

 Structures and Functions

• A structure can be passed as argument to

a function.
• A function can also return a structure.
• The process shall be illustrated with the
help of an example.
– A function to add two complex numbers.

Spring Semester 2011 Programming and Data Structure 47

 Example: complex number addition
#include <stdio.h> struct complex add (x, y)
struct complex { struct complex x, y;
float re; {
float im; struct complex t;
};
t.re = x.re + y.re ;
main() t.im = x.im + y.im ;
{ return (t) ;
struct complex a, b, c; }
scanf (”%f %f”, &a.re, &a.im);
scanf (”%f %f”, &b.re, &b.im);
c = add (a, b) ;
printf (”\n %f %f”, c,re, c.im);
}

Spring Semester 2011 Programming and Data Structure 48

 With typedef
#include <stdio.h> complex add (complex x,
typedef struct { complex y)
float re; {
float im; complex t;
} complex;
t.re = x.re + y.re ;
main() t.im = x.im + y.im ;
{ return (t) ;
complex a, b, c; }
scanf (”%f %f”, &a.re, &a.im);
scanf (”%f %f”, &b.re, &b.im);
c = add (a, b) ;
printf (”\n %f %f”, c,re, c.im);
}

Spring Semester 2011 Programming and Data Structure 49

 Example: Alternative way using
pointers
#include <stdio.h> void add (x, y, t)
typedef struct { complex *x, *y, *t;
float re; {
float im; t->re = x->re + y->re;
} complex; t->im = x->im + y->im;
}
main()
{
complex a, b, c;
scanf (”%f %f”, &a.re, &a.im);
scanf (”%f %f”, &b.re, &b.im);
add (&a, &b, &c) ;
printf (”\n %f %f”, c,re, c.im);
}

Spring Semester 2011 Programming and Data Structure 50