MSc: Introduction to C Programming

Lecture 6. Pointers

In this lecture we will cover :

1. Pointers – the basics 1

2. Pointers and arrays 5
3. Multi-dimensional arrays 9
4. Pointer to a pointer 12
5. Pointer arguments to functions – call by reference 13
6. Call-by-reference with arrays and array elements 16
7. Array arguments to functions 18
8. Pointers and dynamic allocation of memory 20
9. Pitfalls in dynamic memory allocation 25
 Introduction to C Programming Lecture 6 - Pointers

1. Pointers – the basics

A pointer provides a means of accessing the value of a variable.
Essentially, a pointer represents the address of a variable, in other words
it is a memory location. Typically, on most computer architectures, a
pointer is a 32-bit word.

The simple example below shows how an integer variable number can be
accessed through a pointer to it which is called p_number :

int number=10;

int* p_number=&number;

(*p_number)++; /* Increment number */

This example shows the use of the two operators that we use when
manipulating pointers –

 the address of operator &

 the indirection (or contents of) operator *.

p_number is said to “point to” number. Also, the “contents of” the
memory location (p_number) contain the value number. Both these
descriptions are interchangeably used when discussing pointers.

The second line of this example declares an integer pointer variable

p_number and initializes it to point to the variable number. Thus
&number returns the address of variable number. The third line accesses
the contents of what the pointer p_number points to through the use of the
contents-of operator. Thus (*p_number) is the same as the variable
number.
Points to
int* p_number int number
(or contains)

The “address of” (&) and “contents of” (*) operators are opposites of
each other:
Contents-of (*) operator
p_number number
Address -of (&) operator

6-1
 Introduction to C Programming Lecture 6 - Pointers

It’s important to realize that pointers are variables just like any other
variable – they just store a 32-bit value which happens to be a memory
location. We can manipulate pointer variables just like any other variable.
The program below gives an example of this.

#include <stdio.h>

int main(void)
{

int number=10;

int* p_number=&number;

printf(“%d %d \n”, number,p_number);

(*p_number)++; /* Increment number */

p_number++; /* Increment p_number */

printf(“%d %d \n”, number,p_number);

return 0;
}
Sample program output

10 268438072
11 268438076

This program prints out both the pointer value and the contents of the
memory location that the pointer points to. It also increments the pointer
value and its contents. As can be seen the value of the pointer is a fairly
meaningless value which is a 32-bit memory location. However, it can be
manipulated like any other variable. For example in this program, its
value is output and it has been incremented. Note that incrementing a
pointer, as we shall see, is a very useful operation for accessing arrays.

This final example shows pointers being used with characters.

6-2
 Introduction to C Programming Lecture 6 - Pointers

#include <stdio.h>

int main(void)
{

char c=’Q’;

char *p_c=&c;

printf(“%c %d \n”, c, p_c);

*p_c=’Z’; /* Re-assign character */

printf(“%c %d \n”, c, p_c);

return 0;
}

Sample program output

Q 268438069
Z 268438069

In this case, the value of the char variable c has been modified through
indirection of the char pointer variable p_c.

6-3
 Introduction to C Programming Lecture 6 - Pointers

Here’s another example:

#include <stdio.h>
int main(void)
{
char my_string[10]="Hello";
char *p_c=&my_string[0]; /* Points to the first char */
printf("%c %d\n", *p_c, p_c);

p_c++; /* Points to the 2nd char */

printf("%c %d\n", *p_c, p_c);

(*p_c)++; /* Still points to the 2nd char, increments the

actual char ‘e’ */

printf("%c %d\n", *p_c, p_c);

return 0;
}

Sample output:

H 703258592
e 703258593
f 703258593

To get from ‘H’ to ‘e’, we used p_c++ to jump to the second element.
Notice how the address has changed from “…92” to “…93”.

Then we used (*p_c++) to increment ‘e’. This results in ‘f’, but the
address is still the same (the second element, ‘…93’).

If we were now to print out the whole string my_string, we would get
“Hfllo”.

6-4
 Introduction to C Programming Lecture 6 - Pointers

2. Pointers and arrays

Pointers and arrays are intimately related. An array variable is actually a

pointer to the first element of the array. As an example, suppose we
declare an array of 5 floating point variables :

float x[5]; /* An array of 5 floats */

Variable x is of type array of float. However, it is usually used as if it

were of type float* (pointer to a float) and pointing to x[0]:

float* x x[0] x[1] x[2] x[3] x[4]

From the above diagram, it is fairly clear that :

x[0] - same as *x
x[1] - same as *(x+1)
x[2] - same as *(x+2)
.
.
x[i] - same as *(x+i)

In other words, the variable (x+i) is a pointer to the ith array element and
hence *(x+i) is the array element x[i].

We can also get another set of equivalent relationships by putting an “&”

on both sides:
&x[0] - same as &*x which simplifies to x
&x[1] - same as (x+1)
&x[2] - same as (x+2)
.
.
&x[i] - same as (x+i)

6-5
 Introduction to C Programming Lecture 6 - Pointers

The example program below shows how an array can be accessed using a
pointer.
#include <stdio.h>

int main(void)
{

int x[5]={0,10,20,30,40};

int* xp=x;
int i;

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

{
printf(“x[%d]= %d \n”, i, *xp);
xp++;
}

return 0;
}

Sample program output

x[0]=0
x[1]=10
x[2]=20
x[3]=30
x[4]=40

In this program, the pointer to the array xp, initially points at the first
element. This is because of the assignment int* xp=x. The statement
inside the for loop, xp++ moves the pointer on one array element to the
right so that it points to the next element.

Incrementing a pointer variable in this way is a common means of

skipping though the elements of an array. It is important to understand
that xp++ moves a pointer on one element irrespective of the size of each
array element. Thus it doesn’t matter if it is an array of integers or an
array of doubles, the pointer is still incremented by one array location.

6-6
 Introduction to C Programming Lecture 6 - Pointers

The following example uses 2 array pointers to reverse the order of an

array.

int main(void)
{

int x[5]={0,10,20,30,40};

int* left=x;
int* right=x+4;
int temp;

while (left<right)
{
temp=*left;
*left++=*right;
*right--=temp;
}

return 0;
}
In this case, the left and right pointers are initialized to point to the first
and last array elements as shown in the diagram. The left and right
pointers are then progressively moved right and left with the statements
*left++=*right and *right--=temp respectively.

x[0] x[1] x[2] x[3] x[4]

left right

Pointers and character strings

A string is just an array of characters and we can use pointers to access

strings just like any other type of array. The following program shows
how one string can be copied into another string and is the basis of the
strcpy() function that we met in lecture 2.

6-7
 Introduction to C Programming Lecture 6 - Pointers

#include <stdio.h>

int main(void)
{
char source[20];
char dest[20];
char* p_s=source;
char* p_d=dest;

printf("Input the source string: ");

scanf("%s",source);
printf("The source string is %s \n ",source);

while (*p_s!=’\0’)
*p_d++=*p_s++;

*p_d=’\0’;

printf("The destination string is %s \n ",dest);

return 0;
}

Sample program output

Input the source string: abcdefghijklmnop

The destination string is abcdefghijklmnop

As can be seen, the character pointers p_s and p_d are initialized to point
to the first elements of the source and destination strings respectively.
The actual string copy is carried out with the statement
*p_d++=*p_s++. It is important to look at this statement closely.
*p_s++ is interpreted as returning the value pointed to by the pointer p_s
followed by incrementing the pointer value. Note the difference between
this and (*p_s)++ which increments the contents of the location pointed
to by p_s.

The other small thing to note about this program is the use of the string
terminator ’\0’ in indicating the end of the string.

6-8
 Introduction to C Programming Lecture 6 - Pointers

3. Multi-dimensional arrays

We saw in lecture 2 that a 2-dimensional array is stored internally as an

array of 1-dimensional arrays. Hence it should come as no surprise that
we can use pointers to access a 2-d array. Let us look again at a 2-d array
in order to see how its elements can be accessed using pointers.

Let’s define a 2-d array a[] as follows :

int a[3][5];

This array is of dimensions 3 rows by 5 columns and is shown in the table

below with the array index of each element indicated.

[0,0] [0,1] [0,2] [0,3] [0,4]

[1,0] [1,1] [1,2] [1,3] [1,4]

[2,0] [2,1] [2,2] [2,3] [2,4]

We can consider this array to be a 3-element column array of row arrays

of 5 elements each as shown below. Each row is accessed by a[i] for
i=0..2.

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

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

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

So, for example, element a[1][2] is the 3rd element of the array pointer to
by a[1]. Here is a program which can output each of the elements of the
2-D array.

6-9
 Introduction to C Programming Lecture 6 - Pointers

#include <stdio.h>

int main(void)
{
int a[][5]={{3,1,6,5,3},{7,2,5,7,1},{8,3,2,6,2}};
int row,col,val;

for (row=0; row<3; row++)

{
for (col=0; col<5; col++)
{
val = a[row][col];
printf(“a[%d][%d]=%d \n”, row, col, val);
}
}
return 0;
}

From the above diagram and what we know already about the relationship
between pointers and 1-dimensional arrays, we can see immediately that
a[0],a[1] and a[2] are pointers (in other words they are of type int*)
which are also (effectively) 1-D integer arrays.

We can rewrite the above program in a slightly different way, to use a

pointer variable (p_row) to access each row in turn.
#include <stdio.h>

int main(void)
{
int a[][5]={{3,1,6,5,3},{7,2,5,7,1},{8,3,2,6,2}};
int row,col,val;
int* p_row;

for (row=0; row<3; row++)

{
p_row=a[row];
for (col=0; col<5; col++)
{
val=*(p_row+col);
printf(“a[%d][%d]=%d \n”,row,col,val);
}
}
return 0;
}

6 - 10
 Introduction to C Programming Lecture 6 - Pointers

Sample program output

a[0][0] = 3
a[0][1] = 1
.
.
a[2][4] = 2

The array is accessed through the statement val=*(p_row+col) where the

pointer p_row points to the start of the current row and hence p_row+col
is a pointer to the element which is col positions along the row.

Another way to access each array element is to recognize the fact that the
elements are stored in row order as shown below.

[0,0] [0,1] [0,2] [0,3] [0,4] [1,0] [1,1] [1,2] [1,3] [1,4] [2,0] [2,1] [2,2] [2,3] [2,4]

Hence, if a pointer p points to the first element, it is simply a matter of

incrementing this pointer to access each consecutive element. The
program below shows how this is done.

#include <stdio.h>

int main(void)
{
int a[][5]={{3,1,6,5,3},{7,2,5,7,1},{8,3,2,6,2}};
int ele,val;
int* p=a[0];

for (ele=0; ele<15; ele++)

{
val=*p++;
printf("element %d = %d \n",ele,val);
}

return 0;
}

6 - 11
 Introduction to C Programming Lecture 6 - Pointers

Sample program output

element 0 = 3
element 1 = 1
.
.
element 14 = 2

However in most applications we will be accessing each element of a 2-D

array as if it were a matrix element e.g. a[1][2]. The method of treating a
2-D array as a concatenated 1-D array is not normally needed.

4. Pointer to a pointer

We have seen how we can access individual rows of our array a[][] using
the pointers a[0], a[1] and a[2]. Imagine that these 3 pointers,
themselves form an array as shown below. We can then set up a pointer to
point to this array of pointers. This will be a pointer to a pointer and is of
type int**.

int** p_a

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

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

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

Pointers to pointers are usually used when multi-dimensional arrays are

dynamically allocated as we shall see later in this lecture.

6 - 12
 Introduction to C Programming Lecture 6 - Pointers

5. Pointer arguments to functions – call by reference

We have seen (lecture 3) how arguments are passed to functions by value.

In other words, function arguments are copied when passed from the
main program into the function. Let’s take another look at the example
we had of passing function arguments by value.

#include <stdio.h>

void increment(int n)
{
n++;
}

int main(void)
{
int number;
printf(“Input a number: ”);
scanf(“%d”,&number);

increment(number);

printf(“The number now equals %d ”,number);

return 0;

Sample program output :

Input a number : 5
The number now equals 5

As can be seen, the value of the argument is left unchanged by the

function. However, the whole point of the function is to increment its
argument. We can achieve this by passing a pointer to the function. Let’s
rewrite the program and pass a pointer argument.

6 - 13
 Introduction to C Programming Lecture 6 - Pointers

#include <stdio.h>

void increment(int* n)
{
(*n)++;
}

int main(void)
{
int number;
printf(“Input a number: ”);
scanf(“%d”,&number);

increment(&number);

printf(“The number now equals %d ”,number);

return 0;

Sample program output :

Input a number : 5
The number now equals 6

We have made 3 modifications to the original program.

 We have passed an integer pointer to the function increment(). In other

words, the argument n is of type int*.

 Inside the function, we de-reference n so that (*n) is incremented.

 In the main program, we take the address of the number when we pass
it to increment() in order to pass a pointer. Thus increment(&number)
is called.

6 - 14
 Introduction to C Programming Lecture 6 - Pointers

The following diagram illustrates what is going on when we pass a

pointer argument to a function. We normally refer to this situation as
calling an argument by reference as opposed to call by value. This
diagram should be compared with the diagram we had when we discussed
call by value.

1. number=5

main program reference

function increment()
on entry
int* &number

2. number=6

main program
program
function increment()
on exit
int* &number

As can be seen, on entry, the argument of increment() points to (or

references) the variable number in the main program. Thus, since we have
a pointer to that variable, we can change its value.

6 - 15
 Introduction to C Programming Lecture 6 - Pointers

6. Call-by-reference with arrays and array elements

Sometimes we need to use call-by-reference to modify array elements,

and sometimes we need to modify pointers to a whole array. Special care
needs to be taken.

Consider the following program. This will swap two integers, e.g. two
elements of the array.

Each element of the array is an integer, so using call-by-reference with

integers means that the function needs to be defined as int * instead of int.
(This is the same as the increment function in the previous section).

Notice the arguments of swap in the main program also need to be int *.

void swap (int *a, int *b)

{
int temp;
temp = *a;
*a = *b;
*b = temp;
}

int main(void)
{
int i, array[]={10,20,30,40,50};

swap (&array[0], &array[1]);

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

printf (“%d ”, array[i]);
}

Program output:
20 10 30 40 50

In the next program, we set up two pointers in the main program so that
they are both pointing to the first element of two separate arrays.

We can swap these two pointers. This has the effect of swapping the two
arrays, but not swapping the elements within the array. However, the
swap function must now be redefined so that it is swapping two int *

6 - 16
 Introduction to C Programming Lecture 6 - Pointers

variables (pa, pb). Call-by-reference means that the arguments to the

function must now become int **.

void p_swap (int **pa, int **pb)

{
int *temp;
temp = *pa;
*pa = *pb;
*pb = temp;
}

int main(void)
{
int i, array_a[]={10,20,30,40,50}, array_b[]={60,70,80,90,100};
int *p_array_a = array_a;
int *p_array_b = array_b;

p_swap (&p_array_a, &p_array_b);

printf("p_array_a now points to: ");

for (i=0; i<5; i++)
printf ("%d ", p_array_a[i]);

printf("\n p_array_b now points to: ");

for (i=0; i<5; i++)
printf ("%d ", p_array_b[i]);

return 0;
}

Program output:

p_array_a now points to: 60 70 80 90 100

p_array_b now points to: 10 20 30 40 50

Another way of looking at it is that p_array_a is equivalent to

&p_array_a[0], so &p_array_a equates to &&p_array_a[0] (hence the
double pointer).

In general, when we are performing call-by-reference on an argument of a

particular data type, then the function prototype for that argument needs
to be defined with an additional *, e.g. float becomes float *, char
becomes char *, and char * becomes char **.

6 - 17
 Introduction to C Programming Lecture 6 - Pointers

7. Array arguments to functions

A straightforward extension of passing pointers to functions is to pass

array arguments to functions using pointers since array names are just
pointers to the first array element. As an example, lets re-write the
function increment() to increment all of the elements of an array
argument.

#include <stdio.h>

void increment(int* a, int n)

{
int i;
for (i=0; i<n; i++)
a[i]++;
}

int main(void)
{

int array[]={0,1,2,3,4};
int i;

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

printf("array[%d] = %d \n",i,array[i]);

increment(array,5);

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

printf("array[%d] = %d \n",i,array[i]);

return 0;
}

Sample program output

array[0] = 0
array[1] = 1
.
.
array[4] = 4

6 - 18
 Introduction to C Programming Lecture 6 - Pointers

array[0] = 1
array[1] = 2
.
.
array[4] = 5

In this case, simply passing the array name (array) to increment()

automatically passes a pointer.

6 - 19
 Introduction to C Programming Lecture 6 - Pointers

8. Pointers and dynamic allocation of memory

In our C programs to date, we haven’t had to worry about how the

memory allocated to each declared variable has been allocated. Memory
allocation and de-allocation has been done automatically for us. So for
example, if we declare a local variable in a function, memory space for
that variable is automatically allocated when the function is entered and
de-allocated when the function exits. Memory space known as the
program stack is used for this automatic memory allocation/de-allocation.

We often want the facility to manage the memory allocation/de-allocation

ourselves. Dynamic variables are variables whose memory is allocated
and de-allocated by the programmer. This provides more flexibility as
well as providing a lot of opportunities for program crashes! Dynamic
variables are allocated on a memory space known as the heap or the free
store.

C uses 2 functions calloc() and malloc() to allocate memory to dynamic

variables and free() to de-allocate that memory. The headers for these
functions are as follows :

void *calloc(size_t number_of_elements, size_t element_size)

 Allocates a contiguous block of memory.

 Initialises the block to zero.
 Returns the address of the start of the block.

void *malloc(size_t size_of_space)

 Allocates a contiguous block of memory.

 Returns the address of the start of the block.

void free(void *addr_ptr);

 De-allocate the block of memory pointed to by addr_ptr.

calloc() and malloc() are functions which take arguments of type size_t.
This is an unsigned integer returned by the sizeof() function which is the
size (in bytes) of a data type. Thus size_of(int) would return 4 since an
integer normally occupies 4 bytes of memory. Also calloc() and malloc()

6 - 20
 Introduction to C Programming Lecture 6 - Pointers

return a void* data type. This is a pointer which can be cast to any other
type of object pointer. Thus calloc() and malloc() return a pointer to the
area of memory allocated. This memory can be subsequently de-allocated
by a call to free() by using this pointer as the argument to free(). calloc()
and malloc() perform similar tasks. calloc() requires the number of
storage elements and the amount of memory allocated per element whilst
malloc() requires the total amount of memory to be allocated. The other
difference is that calloc() initializes the allocated memory to zero.

For the rest of this course we will be using malloc.

The program below gives an example of dynamically allocating and de-

allocating memory for an array.

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int* ptr_array,i;
int length;

printf(“Enter length of array : ”);

scanf(“%d”,&length);

/* Allocate memory */
ptr_array = (int*)malloc(length*sizeof(int));

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

ptr_array[i]=0;

/* de-allocate memory */
free(ptr_array);

return 0;
}
}

6 - 21
 Introduction to C Programming Lecture 6 - Pointers

Following the call to malloc(), an array is created which is pointed to and

can be accessed through the pointer ptr_array as shown in the diagram.
Note that the return variable from malloc() has to be cast to the correct
type.

int * ptr_array

The next example shows how a 2-d array can be allocated. This makes
use of the pointer-to-a-pointer idea which we met earlier. Essentially, we
allocate memory for the 1-d column array of pointers and then allocate
memory for each 1-d row array.
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int** matrix;
int nrows,ncols,row,col;

printf(“Enter the number of rows and columns : ”);

scanf(“%d %d”,&nrows,&ncols);

/* Allocate memory for the pointer array*/

matrix= (int**)(malloc(nrows*sizeof(int*)));

/* Allocate each row of the matrix */

for (row=0; row<nrows; row++)
matrix[row]=(int*)(malloc(ncols*sizeof(int)));

/* Set all the matrix elements to zero */

for (row=0; row<nrows; row++)
for (col=0; col<ncols; col++)
matrix[row][col]=0;
/* We also need “free” the array here */
return 0;
}
6 - 22
 Introduction to C Programming Lecture 6 - Pointers

The above program then has a 2-d array matrix which is dynamically
allocated. Note again that the return variable from malloc() has to be cast
to the correct type.

int** matrix

As can be seen from the program, the main advantage with this approach
over and above allocating the memory automatically is that the size of the
array is determined at run-time. In this simple example, the matrix size
depends on user inputted values. In contrast, using declaring the matrix
as an automatic variable such as int matrix[4][5] fixes the upper limit of
the size of the matrix which could be inconvenient or wasteful of
memory.

In the previous program, we initialized each element of the 2d matrix to

zero. In other applications, we might instead read the matrix data from the
user, a file or another function.

When writing a large program, it is convenient to create functions for

allocating and de-allocating 2d arrays. The program below contains two
functions – allocate() and de-allocate(). Note how allocate() returns an
int** type which points to the allocated 2d array.

Note also the order of the free functions within the de_allocate function.
In C, 2d arrays must be freed in the reverse order they were created. So
we see that each row is freed, and then the whole 2d array variable is
freed. This is opposite to the order they were allocated.

6 - 23
 Introduction to C Programming Lecture 6 - Pointers

int** allocate(int nrows, int ncols)

{
int row;
/* Allocate memory for the pointer array*/
matrix= (int**)(malloc(nrows*sizeof(int*)));

/* Allocate each row of the matrix */

for (row=0; row<nrows; row++)
matrix[row]=(int*)(malloc(ncols*sizeof(int)));

return matrix;
}

void de_allocate(int** matrix, int nrows)

{
int row;
/* De-allocate each row of the matrix */
for (row=0; row<nrows; row++)
free(matrix[row]);

/* De-allocate memory for the pointer array*/

free(matrix);

int main(void)
{
int** matrix;
int nrows, ncols, row, col;

printf(“Enter the number of rows and columns : ”);

scanf(“%d %d”,&nrows,&ncols);

/* Allocate the matrix the matrix */

matrix=allocate(nrows,ncols);

/* Set all the elements to zero */

for (row=0; row<nrows; row++)
for (col=0; col<ncols; col++)
matrix[row][col]=0;

/* de-allocate the matrix */

de_allocate(matrix);

return 0;
}
6 - 24
 Introduction to C Programming Lecture 6 - Pointers

9. Pitfalls in dynamic memory allocation

Dynamic memory problems can occur on ALL types of systems –

desktop systems, multi-user systems and so on. It does not matter how
much memory is installed within the computer. Additional problems are
faced when programming embedded systems (see lecture 5).

There are 2 main pitfalls in dynamic memory allocation which cause run-
time errors in programs which are sometimes difficult to trace.

 Un-referenced memory (memory ‘leaks’).

 Dangling pointers

Example 1. Un-referenced memory.

This occurs when a pointer, initially pointing at some memory location, is

re-assigned and that memory location is now not referenced and hence
can never again be accessed. The program segment below shows how
easily this can occur.

int* p;
int q=2;
p=(int*)(malloc(5*sizeof(int)));
p=&q; /*creates unreferenced memory */

This program segment creates an un-referenced segment of memory

corresponding to 5 integers.

Un-referenced

p q

On an embedded system, for example, which relies on a relatively small

amount of on-chip memory, if such a piece of code was repeatedly
executed, then the whole system could crash as the program would
eventually run out of memory.

6 - 25
 Introduction to C Programming Lecture 6 - Pointers

Example 2 – dangling pointers.

In this case, the memory referenced by a pointer is de-allocated but the

program still attempts to access the memory through the pointer.

void f(int* x)
{
…
free(x);
}

int main(void)
{
int i;
int* iarray=(int*)(malloc(5*sizeof(int)));
f(iarray); /* creates dangling pointer */
for (i=0; i<5; i++)
iarray[i]=0; /* accesses memory which
doesn’t exist */

return 0;
}

In this case function f() de-allocates the memory which is later

referenced.

6 - 26