Chapter 12: Pointers and Arrays

Copyright 2008 W. W. Norton & Company.

All rights reserved.
1
Chapter 12
Pointers and Arrays
Chapter 12: Pointers and Arrays
Introduction
C allows us to perform arithmeticaddition and
subtractionon pointers to array elements.
This leads to an alternative way of processing
arrays in which pointers take the place of array
subscripts.
The relationship between pointers and arrays in C
is a close one.
Understanding this relationship is critical for
mastering C.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
2
Chapter 12: Pointers and Arrays
Pointer Arithmetic
Chapter 11 showed that pointers can point to array
elements:
i nt a[ 10] , *p;
p = &a[ 0] ;
A graphical representation:
Copyright 2008 W. W. Norton & Company.
All rights reserved.
3
Chapter 12: Pointers and Arrays
Pointer Arithmetic
We can now access a[ 0] through p; for example,
we can store the value 5 in a[ 0] by writing
*p = 5;
An updated picture:
Copyright 2008 W. W. Norton & Company.
All rights reserved.
4
Chapter 12: Pointers and Arrays
Pointer Arithmetic
If p points to an element of an array a, the other
elements of a can be accessed by performing
pointer arithmetic (or address arithmetic) on p.
C supports three (and only three) forms of pointer
arithmetic:
Adding an integer to a pointer
Subtracting an integer from a pointer
Subtracting one pointer from another
Copyright 2008 W. W. Norton & Company.
All rights reserved.
5
Chapter 12: Pointers and Arrays
Adding an Integer to a Pointer
Adding an integer j to a pointer p yields a pointer
to the element j places after the one that p points
to.
More precisely, if p points to the array element
a[ i ] , then p +j points to a[ i +j ] .
Assume that the following declarations are in
effect:
i nt a[ 10] , *p, *q, i ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
6
Chapter 12: Pointers and Arrays
Adding an Integer to a Pointer
Example of pointer addition:
p = &a[ 2] ;
q = p + 3;
p += 6;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
7
Chapter 12: Pointers and Arrays
Subtracting an Integer from a Pointer
If p points to a[ i ] , then p - j points to a[ i - j ] .
Example:
p = &a[ 8] ;
q = p - 3;
p - = 6;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
8
Chapter 12: Pointers and Arrays
Subtracting One Pointer from Another
When one pointer is subtracted from another, the result
is the distance (measured in array elements) between the
pointers.
If p points to a[ i ] and q points to a[ j ] , then p - q is
equal to i - j .
Example:
p = &a[ 5] ;
q = &a[ 1] ;
i = p - q; / * i i s 4 */
i = q - p; / * i i s - 4 */
Copyright 2008 W. W. Norton & Company.
All rights reserved.
9
Chapter 12: Pointers and Arrays
Subtracting One Pointer from Another
Operations that cause undefined behavior:
Performing arithmetic on a pointer that doesnt point to
an array element
Subtracting pointers unless both point to elements of
the same array
Copyright 2008 W. W. Norton & Company.
All rights reserved.
10
Chapter 12: Pointers and Arrays
Comparing Pointers
Pointers can be compared using the relational
operators (<, <=, >, >=) and the equality operators
(==and ! =).
Using relational operators is meaningful only for pointers to
elements of the same array.
The outcome of the comparison depends on the
relative positions of the two elements in the array.
After the assignments
p = &a[ 5] ;
q = &a[ 1] ;
the value of p <=q is 0 and the value of p >=q is 1.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
11
Chapter 12: Pointers and Arrays
Pointers to Compound Literals (C99)
Its legal for a pointer to point to an element
within an array created by a compound literal:
i nt *p = ( i nt [ ] ) {3, 0, 3, 4, 1};
Using a compound literal saves us the trouble of
first declaring an array variable and then making p
point to the first element of that array:
i nt a[ ] = {3, 0, 3, 4, 1};
i nt *p = &a[ 0] ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
12
Chapter 12: Pointers and Arrays
Using Pointers for Array Processing
Pointer arithmetic allows us to visit the elements
of an array by repeatedly incrementing a pointer
variable.
A loop that sums the elements of an array a:
#def i ne N 10

i nt a[ N] , sum, *p;

sum= 0;
f or ( p = &a[ 0] ; p < &a[ N] ; p++)
sum+= *p;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
13
Chapter 12: Pointers and Arrays
Using Pointers for Array Processing
At the end of the first iteration:
At the end of the second iteration:
At the end of the third iteration:
Copyright 2008 W. W. Norton & Company.
All rights reserved.
14
Chapter 12: Pointers and Arrays
Using Pointers for Array Processing
The condition p < &a[ N] in the f or statement
deserves special mention.
Its legal to apply the address operator to a[ N] ,
even though this element doesnt exist.
Pointer arithmetic may save execution time.
However, some C compilers produce better code
for loops that rely on subscripting.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
15
Chapter 12: Pointers and Arrays
Combining the * and ++ Operators
C programmers often combine the * (indirection)
and ++operators.
A statement that modifies an array element and
then advances to the next element:
a[ i ++] = j ;
The corresponding pointer version:
*p++ = j ;
Because the postfix version of ++takes
precedence over *, the compiler sees this as
*( p++) = j ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
16
Chapter 12: Pointers and Arrays
Combining the * and ++ Operators
Possible combinations of * and ++:
Expression Meaning
*p++or *( p++) Value of expression is *p before increment;
increment p later
( *p) ++ Value of expression is *p before increment;
increment *p later
*++p or *( ++p) Increment p first;
value of expression is *p after increment
++*p or ++( *p) Increment *p first;
value of expression is *p after increment
Copyright 2008 W. W. Norton & Company.
All rights reserved.
17
Chapter 12: Pointers and Arrays
Combining the * and ++ Operators
The most common combination of * and ++is
*p++, which is handy in loops.
Instead of writing
f or ( p = &a[ 0] ; p < &a[ N] ; p++)
sum+= *p;
to sum the elements of the array a, we could write
p = &a[ 0] ;
whi l e ( p < &a[ N] )
sum+= *p++;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
18
Chapter 12: Pointers and Arrays
Combining the * and ++ Operators
The * and - - operators mix in the same way as *
and ++.
For an application that combines * and - - , lets
return to the stack example of Chapter 10.
The original version of the stack relied on an
integer variable named t op to keep track of the
top-of-stack position in the contents array.
Lets replace t op by a pointer variable that points
initially to element 0 of the cont ent s array:
i nt *t op_pt r = &cont ent s[ 0] ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
19
Chapter 12: Pointers and Arrays
Combining the * and ++ Operators
The new push and pop functions:
voi d push( i nt i )
{
i f ( i s_f ul l ( ) )
st ack_over f l ow( ) ;
el se
*t op_pt r ++ = i ;
}
i nt pop( voi d)
{
i f ( i s_empt y( ) )
st ack_under f l ow( ) ;
el se
r et ur n *- - t op_pt r ;
}
Copyright 2008 W. W. Norton & Company.
All rights reserved.
20
Chapter 12: Pointers and Arrays
Using an Array Name as a Pointer
Pointer arithmetic is one way in which arrays and
pointers are related.
Another key relationship:
The name of an array can be used as a pointer to
the first element in the array.
This relationship simplifies pointer arithmetic and
makes both arrays and pointers more versatile.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
21
Chapter 12: Pointers and Arrays
Using an Array Name as a Pointer
Suppose that a is declared as follows:
i nt a[ 10] ;
Examples of using a as a pointer:
*a = 7; / * st or es 7 i n a[ 0] */
*( a+1) = 12; / * st or es 12 i n a[ 1] */
In general, a +i is the same as &a[ i ] .
Both represent a pointer to element i of a.
Also, *( a+i ) is equivalent to a[ i ] .
Both represent element i itself.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
22
Chapter 12: Pointers and Arrays
Using an Array Name as a Pointer
The fact that an array name can serve as a pointer
makes it easier to write loops that step through an
array.
Original loop:
f or ( p = &a[ 0] ; p < &a[ N] ; p++)
sum+= *p;
Simplified version:
f or ( p = a; p < a + N; p++)
sum+= *p;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
23
Chapter 12: Pointers and Arrays
Using an Array Name as a Pointer
Although an array name can be used as a pointer,
its not possible to assign it a new value.
Attempting to make it point elsewhere is an error:
whi l e ( *a ! = 0)
a++; / *** WRONG ***/
This is no great loss; we can always copy a into a
pointer variable, then change the pointer variable:
p = a;
whi l e ( *p ! = 0)
p++;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
24
Chapter 12: Pointers and Arrays
Program: Reversing a Series
of Numbers (Revisited)
The r ever se. c program of Chapter 8 reads 10
numbers, then writes the numbers in reverse order.
The original program stores the numbers in an
array, with subscripting used to access elements of
the array.
r ever se3. c is a new version of the program in
which subscripting has been replaced with pointer
arithmetic.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
25
Chapter 12: Pointers and Arrays
reverse3.c
/ * Rever ses a ser i es of number s ( poi nt er ver si on) */
#i ncl ude <st di o. h>
#def i ne N 10
i nt mai n( voi d)
{
i nt a[ N] , *p;
pr i nt f ( "Ent er %d number s: ", N) ;
f or ( p = a; p < a + N; p++)
scanf ( "%d", p) ;
pr i nt f ( "I n r ever se or der : ") ;
f or ( p = a + N - 1; p >= a; p- - )
pr i nt f ( " %d", *p) ;
pr i nt f ( "\ n") ;
r et ur n 0;
}
Copyright 2008 W. W. Norton & Company.
All rights reserved.
26
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
When passed to a function, an array name is treated as a pointer.
Example:
i nt f i nd_l ar gest ( i nt a[ ] , i nt n)
{
i nt i , max;
max = a[ 0] ;
f or ( i = 1; i < n; i ++)
i f ( a[ i ] > max)
max = a[ i ] ;
r et ur n max;
}
A call of f i nd_l ar gest :
l ar gest = f i nd_l ar gest ( b, N) ;
This call causes a pointer to the first element of b to be assigned
to a; the array itself isnt copied.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
27
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
The fact that an array argument is treated as a
pointer has some important consequences.
Consequence 1: When an ordinary variable is
passed to a function, its value is copied; any
changes to the corresponding parameter dont
affect the variable.
In contrast, an array used as an argument isnt
protected against change.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
28
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
For example, the following function modifies an
array by storing zero into each of its elements:
voi d st or e_zer os( i nt a[ ] , i nt n)
{
i nt i ;
f or ( i = 0; i < n; i ++)
a[ i ] = 0;
}
Copyright 2008 W. W. Norton & Company.
All rights reserved.
29
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
To indicate that an array parameter wont be
changed, we can include the word const in its
declaration:
i nt f i nd_l ar gest ( const i nt a[ ] , i nt n)
{

}
If const is present, the compiler will check that
no assignment to an element of a appears in the
body of f i nd_l ar gest .
Copyright 2008 W. W. Norton & Company.
All rights reserved.
30
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
Consequence 2: The time required to pass an array
to a function doesnt depend on the size of the
array.
Theres no penalty for passing a large array, since
no copy of the array is made.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
31
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
Consequence 3: An array parameter can be
declared as a pointer if desired.
f i nd_l ar gest could be defined as follows:
i nt f i nd_l ar gest ( i nt *a, i nt n)
{

}
Declaring a to be a pointer is equivalent to
declaring it to be an array; the compiler treats the
declarations as though they were identical.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
32
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
Although declaring a parameter to be an array is
the same as declaring it to be a pointer, the same
isnt true for a variable.
The following declaration causes the compiler to
set aside space for 10 integers:
i nt a[ 10] ;
The following declaration causes the compiler to
allocate space for a pointer variable:
i nt *a;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
33
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
In the latter case, a is not an array; attempting to
use it as an array can have disastrous results.
For example, the assignment
*a = 0; / *** WRONG ***/
will store 0 where a is pointing.
Since we dont know where a is pointing, the
effect on the program is undefined.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
34
Chapter 12: Pointers and Arrays
Array Arguments (Revisited)
Consequence 4: A function with an array
parameter can be passed an array slicea
sequence of consecutive elements.
An example that applies f i nd_l ar gest to
elements 5 through 14 of an array b:
l ar gest = f i nd_l ar gest ( &b[ 5] , 10) ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
35
Chapter 12: Pointers and Arrays
Using a Pointer as an Array Name
C allows us to subscript a pointer as though it
were an array name:
#def i ne N 10

i nt a[ N] , i , sum= 0, *p = a;

f or ( i = 0; i < N; i ++)
sum+= p[ i ] ;
The compiler treats p[ i ] as *( p+i ) .
Copyright 2008 W. W. Norton & Company.
All rights reserved.
36
Chapter 12: Pointers and Arrays
Pointers and Multidimensional Arrays
J ust as pointers can point to elements of one-
dimensional arrays, they can also point to
elements of multidimensional arrays.
This section explores common techniques for
using pointers to process the elements of
multidimensional arrays.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
37
Chapter 12: Pointers and Arrays
Processing the Elements
of a Multidimensional Array
Chapter 8 showed that C stores two-dimensional
arrays in row-major order.
Layout of an array with r rows:
If p initially points to the element in row 0, column 0,
we can visit every element in the array by
incrementing p repeatedly.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
38
Chapter 12: Pointers and Arrays
Processing the Elements
of a Multidimensional Array
Consider the problem of initializing all elements of the following
array to zero:
i nt a[ NUM_ROWS] [ NUM_COLS] ;
The obvious technique would be to use nested f or loops:
i nt r ow, col ;

f or ( r ow = 0; r ow < NUM_ROWS; r ow++)

f or ( col = 0; col < NUM_COLS; col ++)
a[ r ow] [ col ] = 0;
If we view a as a one-dimensional array of integers, a single loop
is sufficient:
i nt *p;

f or ( p =&a[ 0] [ 0] ; p <=&a[ NUM_ROWS- 1] [ NUM_COLS- 1] ; p++)

*p =0;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
39
Chapter 12: Pointers and Arrays
Processing the Elements
of a Multidimensional Array
Although treating a two-dimensional array as one-
dimensional may seem like cheating, it works with
most C compilers.
Techniques like this one definitely hurt program
readability, butat least with some older
compilersproduce a compensating increase in
efficiency.
With many modern compilers, though, theres
often little or no speed advantage.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
40
Chapter 12: Pointers and Arrays
Processing the Rows
of a Multidimensional Array
A pointer variable p can also be used for
processing the elements in just one row of a two-
dimensional array.
To visit the elements of row i , wed initialize p to
point to element 0 in row i in the array a:
p = &a[ i ] [ 0] ;
or we could simply write
p = a[ i ] ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
41
Chapter 12: Pointers and Arrays
Processing the Rows
of a Multidimensional Array
For any two-dimensional array a, the expression
a[ i ] is a pointer to the first element in row i .
To see why this works, recall that a[ i ] is
equivalent to *( a +i ) .
Thus, &a[ i ] [ 0] is the same as &( *( a[ i ] +0) ) ,
which is equivalent to &*a[ i ] .
This is the same as a[ i ] , since the &and *
operators cancel.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
42
Chapter 12: Pointers and Arrays
Processing the Rows
of a Multidimensional Array
A loop that clears row i of the array a:
i nt a[ NUM_ROWS] [ NUM_COLS] , *p, i ;

f or ( p = a[ i ] ; p < a[ i ] + NUM_COLS; p++)

*p = 0;
Since a[ i ] is a pointer to row i of the array a, we
can pass a[ i ] to a function thats expecting a one-
dimensional array as its argument.
In other words, a function thats designed to work
with one-dimensional arrays will also work with a
row belonging to a two-dimensional array.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
43
Chapter 12: Pointers and Arrays
Processing the Rows
of a Multidimensional Array
Consider f i nd_l ar gest , which was originally
designed to find the largest element of a one-
dimensional array.
We can just as easily use f i nd_l ar gest to
determine the largest element in row i of the two-
dimensional array a:
l ar gest = f i nd_l ar gest ( a[ i ] , NUM_COLS) ;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
44
Chapter 12: Pointers and Arrays
Processing the Columns
of a Multidimensional Array
Processing the elements in a column of a two-
dimensional array isnt as easy, because arrays are
stored by row, not by column.
A loop that clears column i of the array a:
i nt a[ NUM_ROWS] [ NUM_COLS] , ( *p) [ NUM_COLS] , i ;

f or ( p = &a[ 0] ; p < &a[ NUM_ROWS] ; p++)

( *p) [ i ] = 0;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
45
Chapter 12: Pointers and Arrays
Using the Name of a
Multidimensional Array as a Pointer
The name of any array can be used as a pointer, regardless
of how many dimensions it has, but some care is required.
Example:
i nt a[ NUM_ROWS] [ NUM_COLS] ;
a is not a pointer to a[ 0] [ 0] ; instead, its a pointer to
a[ 0] .
C regards a as a one-dimensional array whose elements are
one-dimensional arrays.
When used as a pointer, a has type i nt ( *) [ NUM_COLS]
(pointer to an integer array of length NUM_COLS).
Copyright 2008 W. W. Norton & Company.
All rights reserved.
46
Chapter 12: Pointers and Arrays
Using the Name of a
Multidimensional Array as a Pointer
Knowing that a points to a[ 0] is useful for
simplifying loops that process the elements of a
two-dimensional array.
Instead of writing
f or ( p = &a[ 0] ; p < &a[ NUM_ROWS] ; p++)
( *p) [ i ] = 0;
to clear column i of the array a, we can write
f or ( p = a; p < a + NUM_ROWS; p++)
( *p) [ i ] = 0;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
47
Chapter 12: Pointers and Arrays
Using the Name of a
Multidimensional Array as a Pointer
We can trick a function into thinking that a
multidimensional array is really one-dimensional.
A first attempt at using using f i nd_l ar gest to find the
largest element in a:
l ar gest = f i nd_l ar gest ( a, NUM_ROWS * NUM_COLS) ;
/ * WRONG */
This an error, because the type of a is i nt ( *) [ NUM_COLS]
but f i nd_l ar gest is expecting an argument of type i nt *.
The correct call:
l ar gest = f i nd_l ar gest ( a[ 0] , NUM_ROWS * NUM_COLS) ;
a[ 0] points to element 0 in row 0, and it has type i nt *
(after conversion by the compiler).
Copyright 2008 W. W. Norton & Company.
All rights reserved.
48
Chapter 12: Pointers and Arrays
Pointers and Variable-Length Arrays (C99)
Pointers are allowed to point to elements of
variable-length arrays (VLAs).
An ordinary pointer variable would be used to
point to an element of a one-dimensional VLA:
voi d f ( i nt n)
{
i nt a[ n] , *p;
p = a;

}
Copyright 2008 W. W. Norton & Company.
All rights reserved.
49
Chapter 12: Pointers and Arrays
Pointers and Variable-Length Arrays (C99)
When the VLA has more than one dimension, the
type of the pointer depends on the length of each
dimension except for the first.
A two-dimensional example:
voi d f ( i nt m, i nt n)
{
i nt a[ m] [ n] , ( *p) [ n] ;
p = a;

}
Since the type of p depends on n, which isnt
constant, p is said to have a variably modified type.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
50
Chapter 12: Pointers and Arrays
Pointers and Variable-Length Arrays (C99)
The validity of an assignment such as p =a cant
always be determined by the compiler.
The following code will compile but is correct
only if mand n are equal:
i nt a[ m] [ n] , ( *p) [ m] ;
p = a;
If mis not equal to n, any subsequent use of p will
cause undefined behavior.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
51
Chapter 12: Pointers and Arrays
Pointers and Variable-Length Arrays (C99)
Variably modified types are subject to certain
restrictions.
The most important restriction: the declaration of
a variably modified type must be inside the body
of a function or in a function prototype.
Copyright 2008 W. W. Norton & Company.
All rights reserved.
52
Chapter 12: Pointers and Arrays
Pointers and Variable-Length Arrays (C99)
Pointer arithmetic works with VLAs.
A two-dimensional VLA:
i nt a[ m] [ n] ;
A pointer capable of pointing to a row of a:
i nt ( *p) [ n] ;
A loop that clears column i of a:
f or ( p = a; p < a + m; p++)
( *p) [ i ] = 0;
Copyright 2008 W. W. Norton & Company.
All rights reserved.
53