Back to Chapter 4 -- Index -- Chapter 6
Pointers have been lumped with the goto statement as a marvelous way to create impossible-to-understand programs. This is certainly true when they are used carelessly, and it is easy to create pointers that point somewhere unexpected. With discipline, however, pointers can also be used to achieve clarity and simplicity. This is the aspect that we will try to illustrate.
The main change in ANSI C is to make explicit the rules about how pointers can be manipulated, in effect mandating what good programmers already practice and good compilers already enforce. In addition, the type void * (pointer to void) replaces char * as the proper type for a generic pointer.
The unary operator & gives the address of an object, so the statement
p = &c;
assigns the address of c to the variable p, and p
is said to ``point to'' c. The & operator only applies
to objects in memory: variables and array elements. It cannot be applied to
expressions, constants, or register variables.
The unary operator * is the indirection or dereferencing operator; when applied to a pointer, it accesses the object the pointer points to. Suppose that x and y are integers and ip is a pointer to int. This artificial sequence shows how to declare a pointer and how to use & and *:
int x = 1, y = 2, z[10];
int *ip; /* ip is a pointer to int */
ip = &x; /* ip now points to x */
y = *ip; /* y is now 1 */
*ip = 0; /* x is now 0 */
ip = &z[0]; /* ip now points to z[0] */
The declaration of x, y, and z are what we've seen
all along. The declaration of the pointer ip,
int *ip;
is intended as a mnemonic; it says that the expression *ip is an
int. The syntax of the declaration for a variable mimics the syntax
of expressions in which the variable might appear. This reasoning applies to
function declarations as well. For example,
double *dp, atof(char *);
says that in an expression *dp and atof(s) have values of
double, and that the argument of atof is a pointer to
char.
You should also note the implication that a pointer is constrained to point to a particular kind of object: every pointer points to a specific data type. (There is one exception: a ``pointer to void'' is used to hold any type of pointer but cannot be dereferenced itself. We'll come back to it in Section 5.11.)
If ip points to the integer x, then *ip can occur in any context where x could, so
*ip = *ip + 10;
increments *ip by 10.
The unary operators * and & bind more tightly than arithmetic operators, so the assignment
y = *ip + 1
takes whatever ip points at, adds 1, and assigns the result to
y, while
*ip += 1
increments what ip points to, as do
++*ip
and
(*ip)++
The parentheses are necessary in this last example; without them, the
expression would increment ip instead of what it points to, because
unary operators like * and ++ associate right to left.
Finally, since pointers are variables, they can be used without dereferencing. For example, if iq is another pointer to int,
iq = ip
copies the contents of ip into iq, thus making iq
point to whatever ip pointed to.
swap(a, b);
where the swap function is defined as
void swap(int x, int y) /* WRONG */
{
int temp;
temp = x;
x = y;
y = temp;
}
Because of call by value, swap can't affect the arguments a
and b in the routine that called it. The function above swaps
copies of a and b.
The way to obtain the desired effect is for the calling program to pass pointers to the values to be changed:
swap(&a, &b);
Since the operator & produces the address of a variable,
&a is a pointer to a. In swap itself, the
parameters are declared as pointers, and the operands are accessed indirectly
through them.
void swap(int *px, int *py) /* interchange *px and *py */
{
int temp;
temp = *px;
*px = *py;
*py = temp;
}
Pictorially:
Pointer arguments enable a function to access and change objects in the function that called it. As an example, consider a function getint that performs free-format input conversion by breaking a stream of characters into integer values, one integer per call. getint has to return the value it found and also signal end of file when there is no more input. These values have to be passed back by separate paths, for no matter what value is used for EOF, that could also be the value of an input integer.
One solution is to have getint return the end of file status as its function value, while using a pointer argument to store the converted integer back in the calling function. This is the scheme used by scanf as well; see Section 7.4.
The following loop fills an array with integers by calls to getint:
int n, array[SIZE], getint(int *);
for (n = 0; n < SIZE && getint(&array[n]) != EOF; n++)
;
Each call sets array[n] to the next integer found in the input and
increments n. Notice that it is essential to pass the address of
array[n] to getint. Otherwise there is no way for getint to
communicate the converted integer back to the caller.
Our version of getint returns EOF for end of file, zero if the next input is not a number, and a positive value if the input contains a valid number.
#include <ctype.h>
int getch(void);
void ungetch(int);
/* getint: get next integer from input into *pn */
int getint(int *pn)
{
int c, sign;
while (isspace(c = getch())) /* skip white space */
;
if (!isdigit(c) && c != EOF && c != '+' && c != '-') {
ungetch(c); /* it is not a number */
return 0;
}
sign = (c == '-') ? -1 : 1;
if (c == '+' || c == '-')
c = getch();
for (*pn = 0; isdigit(c), c = getch())
*pn = 10 * *pn + (c - '0');
*pn *= sign;
if (c != EOF)
ungetch(c);
return c;
}
Throughout getint, *pn is used as an ordinary int
variable. We have also used getch and ungetch (described in
Section 4.3) so the one extra character that
must be read can be pushed back onto the input.
Exercise 5-1. As written, getint treats a + or - not followed by a digit as a valid representation of zero. Fix it to push such a character back on the input.
Exercise 5-2. Write getfloat, the floating-point analog of getint. What type does getfloat return as its function value?
The declaration
int a[10];
defines an array of size 10, that is, a block of 10 consecutive objects named
a[0], a[1], ...,a[9].
The notation a[i] refers to the i-th element of the array. If pa is a pointer to an integer, declared as
int *pa;
then the assignment
pa = &a[0];
sets pa to point to element zero of a; that is, pa
contains the address of a[0].
Now the assignment
x = *pa;
will copy the contents of a[0] into x.
If pa points to a particular element of an array, then by definition pa+1 points to the next element, pa+i points i elements after pa, and pa-i points i elements before. Thus, if pa points to a[0],
*(pa+1)
refers to the contents of a[1], pa+i is the address of
a[i], and *(pa+i) is the contents of a[i].
These remarks are true regardless of the type or size of the variables in the array a. The meaning of ``adding 1 to a pointer,'' and by extension, all pointer arithmetic, is that pa+1 points to the next object, and pa+i points to the i-th object beyond pa.
The correspondence between indexing and pointer arithmetic is very close. By definition, the value of a variable or expression of type array is the address of element zero of the array. Thus after the assignment
pa = &a[0];
pa and a have identical values. Since the name of an array
is a synonym for the location of the initial element, the assignment
pa=&a[0] can also be written as
pa = a;
Rather more surprising, at first sight, is the fact that a reference to
a[i] can also be written as *(a+i). In evaluating
a[i], C converts it to *(a+i) immediately; the two forms
are equivalent. Applying the operator & to both parts of this
equivalence, it follows that &a[i] and a+i are also
identical: a+i is the address of the i-th element beyond
a. As the other side of this coin, if pa is a pointer,
expressions might use it with a subscript; pa[i] is identical to
*(pa+i). In short, an array-and-index expression is equivalent to
one written as a pointer and offset.
There is one difference between an array name and a pointer that must be kept in mind. A pointer is a variable, so pa=a and pa++ are legal. But an array name is not a variable; constructions like a=pa and a++ are illegal.
When an array name is passed to a function, what is passed is the location of the initial element. Within the called function, this argument is a local variable, and so an array name parameter is a pointer, that is, a variable containing an address. We can use this fact to write another version of strlen, which computes the length of a string.
/* strlen: return length of string s */
int strlen(char *s)
{
int n;
for (n = 0; *s != '\0', s++)
n++;
return n;
}
Since s is a pointer, incrementing it is perfectly legal; s++ has
no effect on the character string in the function that called strlen,
but merely increments strlen's private copy of the pointer. That means
that calls like
strlen("hello, world"); /* string constant */
strlen(array); /* char array[100]; */
strlen(ptr); /* char *ptr; */
all work.
As formal parameters in a function definition,
char s[];
and
char *s;
are equivalent; we prefer the latter because it says more explicitly that the
variable is a pointer. When an array name is passed to a function, the
function can at its convenience believe that it has been handed either an
array or a pointer, and manipulate it accordingly. It can even use both
notations if it seems appropriate and clear.
It is possible to pass part of an array to a function, by passing a pointer to the beginning of the subarray. For example, if a is an array,
f(&a[2])
and
f(a+2)
both pass to the function f the address of the subarray that starts at
a[2]. Within f, the parameter declaration can read
f(int arr[]) { ... }
or
f(int *arr) { ... }
So as far as f is concerned, the fact that the parameter refers to part
of a larger array is of no consequence.
If one is sure that the elements exist, it is also possible to index backwards in an array; p[-1], p[-2], and so on are syntactically legal, and refer to the elements that immediately precede p[0]. Of course, it is illegal to refer to objects that are not within the array bounds.
C is consistent and regular in its approach to address arithmetic; its integration of pointers, arrays, and address arithmetic is one of the strengths of the language. Let us illustrate by writing a rudimentary storage allocator. There are two routines. The first, alloc(n), returns a pointer to n consecutive character positions, which can be used by the caller of alloc for storing characters. The second, afree(p), releases the storage thus acquired so it can be re-used later. The routines are ``rudimentary'' because the calls to afree must be made in the opposite order to the calls made on alloc. That is, the storage managed by alloc and afree is a stack, or last-in, first-out. The standard library provides analogous functions called malloc and free that have no such restrictions; in Section 8.7 we will show how they can be implemented.
The easiest implementation is to have alloc hand out pieces of a large character array that we will call allocbuf. This array is private to alloc and afree. Since they deal in pointers, not array indices, no other routine need know the name of the array, which can be declared static in the source file containing alloc and afree, and thus be invisible outside it. In practical implementations, the array may well not even have a name; it might instead be obtained by calling malloc or by asking the operating system for a pointer to some unnamed block of storage.
The other information needed is how much of allocbuf has been used. We use a pointer, called allocp, that points to the next free element. When alloc is asked for n characters, it checks to see if there is enough room left in allocbuf. If so, alloc returns the current value of allocp (i.e., the beginning of the free block), then increments it by n to point to the next free area. If there is no room, alloc returns zero. afree(p) merely sets allocp to p if p is inside allocbuf.
#define ALLOCSIZE 10000 /* size of available space */
static char allocbuf[ALLOCSIZE]; /* storage for alloc */
static char *allocp = allocbuf; /* next free position */
char *alloc(int n) /* return pointer to n characters */
{
if (allocbuf + ALLOCSIZE - allocp >= n) { /* it fits */
allocp += n;
return allocp - n; /* old p */
} else /* not enough room */
return 0;
}
void afree(char *p) /* free storage pointed to by p */
{
if (p >= allocbuf && p < allocbuf + ALLOCSIZE)
allocp = p;
}
In general a pointer can be initialized just as any other variable can,
though normally the only meaningful values are zero or an expression
involving the address of previously defined data of appropriate type. The
declaration
static char *allocp = allocbuf;
defines allocp to be a character pointer and initializes it to point to
the beginning of allocbuf, which is the next free position when the
program starts. This could also have been written
static char *allocp = &allocbuf[0];
since the array name is the address of the zeroth element.
The test
if (allocbuf + ALLOCSIZE - allocp >= n) { /* it fits */
checks if there's enough room to satisfy a request for n characters. If
there is, the new value of allocp would be at most one beyond the end
of allocbuf. If the request can be satisfied, alloc returns a
pointer to the beginning of a block of characters (notice the declaration of
the function itself). If not, alloc must return some signal that there
is no space left. C guarantees that zero is never a valid address for data,
so a return value of zero can be used to signal an abnormal event, in this
case no space.
Pointers and integers are not interchangeable. Zero is the sole exception: the constant zero may be assigned to a pointer, and a pointer may be compared with the constant zero. The symbolic constant NULL is often used in place of zero, as a mnemonic to indicate more clearly that this is a special value for a pointer. NULL is defined in <stdio.h>. We will use NULL henceforth.
Tests like
if (allocbuf + ALLOCSIZE - allocp >= n) { /* it fits */
and
if (p >= allocbuf && p < allocbuf + ALLOCSIZE)
show several important facets of pointer arithmetic. First, pointers may be
compared under certain circumstances. If p and q point to
members of the same array, then relations like ==, !=,
<, >=, etc., work properly. For example,
p < q
is true if p points to an earlier element of the array than q
does. Any pointer can be meaningfully compared for equality or inequality
with zero. But the behavior is undefined for arithmetic or comparisons with
pointers that do not point to members of the same array. (There is one
exception: the address of the first element past the end of an array can be
used in pointer arithmetic.)
Second, we have already observed that a pointer and an integer may be added or subtracted. The construction
p + n
means the address of the n-th object beyond the one p
currently points to. This is true regardless of the kind of object p
points to; n is scaled according to the size of the objects
p points to, which is determined by the declaration of p.
If an int is four bytes, for example, the int will be
scaled by four.
Pointer subtraction is also valid: if p and q point to elements of the same array, and p<q, then q-p+1 is the number of elements from p to q inclusive. This fact can be used to write yet another version of strlen:
/* strlen: return length of string s */
int strlen(char *s)
{
char *p = s;
while (*p != '\0')
p++;
return p - s;
}
In its declaration, p is initialized to s, that is, to
point to the first character of the string. In the while loop, each
character in turn is examined until the '\0' at the end is seen.
Because p points to characters, p++ advances p to
the next character each time, and p-s gives the number of characters
advanced over, that is, the string length. (The number of characters in the
string could be too large to store in an int. The header
<stddef.h> defines a type ptrdiff_t that is large
enough to hold the signed difference of two pointer values. If we were being
cautious, however, we would use size_t for the return value of
strlen, to match the standard library version. size_t is
the unsigned integer type returned by the sizeof operator.
Pointer arithmetic is consistent: if we had been dealing with floats, which occupy more storage that chars, and if p were a pointer to float, p++ would advance to the next float. Thus we could write another version of alloc that maintains floats instead of chars, merely by changing char to float throughout alloc and afree. All the pointer manipulations automatically take into account the size of the objects pointed to.
The valid pointer operations are assignment of pointers of the same type, adding or subtracting a pointer and an integer, subtracting or comparing two pointers to members of the same array, and assigning or comparing to zero. All other pointer arithmetic is illegal. It is not legal to add two pointers, or to multiply or divide or shift or mask them, or to add float or double to them, or even, except for void *, to assign a pointer of one type to a pointer of another type without a cast.
"I am a string"
is an array of characters. In the internal representation, the array is
terminated with the null character '\0' so that programs can find
the end. The length in storage is thus one more than the number of characters
between the double quotes.
Perhaps the most common occurrence of string constants is as arguments to functions, as in
printf("hello, world\n");
When a character string like this appears in a program, access to it is
through a character pointer; printf receives a pointer to the beginning
of the character array. That is, a string constant is accessed by a pointer
to its first element.
String constants need not be function arguments. If pmessage is declared as
char *pmessage;
then the statement
pmessage = "now is the time";
assigns to pmessage a pointer to the character array. This is
not a string copy; only pointers are involved. C does not provide
any operators for processing an entire string of characters as a unit.
There is an important difference between these definitions:
char amessage[] = "now is the time"; /* an array */
char *pmessage = "now is the time"; /* a pointer */
amessage is an array, just big enough to hold the sequence of
characters and '\0' that initializes it. Individual characters within
the array may be changed but amessage will always refer to the same
storage. On the other hand, pmessage is a pointer, initialized to point
to a string constant; the pointer may subsequently be modified to point
elsewhere, but the result is undefined if you try to modify the string
contents.
We will illustrate more aspects of pointers and arrays by studying versions of two useful functions adapted from the standard library. The first function is strcpy(s,t), which copies the string t to the string s. It would be nice just to say s=t but this copies the pointer, not the characters. To copy the characters, we need a loop. The array version first:
/* strcpy: copy t to s; array subscript version */
void strcpy(char *s, char *t)
{
int i;
i = 0;
while ((s[i] = t[i]) != '\0')
i++;
}
For contrast, here is a version of strcpy with pointers:
/* strcpy: copy t to s; pointer version */
void strcpy(char *s, char *t)
{
int i;
i = 0;
while ((*s = *t) != '\0') {
s++;
t++;
}
}
Because arguments are passed by value, strcpy can use the parameters
s and t in any way it pleases. Here they are conveniently
initialized pointers, which are marched along the arrays a character at a
time, until the '\0' that terminates t has been copied into
s.
In practice, strcpy would not be written as we showed it above. Experienced C programmers would prefer
/* strcpy: copy t to s; pointer version 2 */
void strcpy(char *s, char *t)
{
while ((*s++ = *t++) != '\0')
;
}
This moves the increment of s and t into the test part of the
loop. The value of *t++ is the character that t pointed to before
t was incremented; the postfix ++ doesn't change t until
after this character has been fetched. In the same way, the character is
stored into the old s position before s is incremented. This
character is also the value that is compared against '\0' to control
the loop. The net effect is that characters are copied from t to
s, up and including the terminating '\0'.
As the final abbreviation, observe that a comparison against '\0' is redundant, since the question is merely whether the expression is zero. So the function would likely be written as
/* strcpy: copy t to s; pointer version 3 */
void strcpy(char *s, char *t)
{
while (*s++ = *t++)
;
}
Although this may seem cryptic at first sight, the notational convenience is
considerable, and the idiom should be mastered, because you will see it
frequently in C programs.
The strcpy in the standard library (<string.h>) returns the target string as its function value.
The second routine that we will examine is strcmp(s,t), which compares the character strings s and t, and returns negative, zero or positive if s is lexicographically less than, equal to, or greater than t. The value is obtained by subtracting the characters at the first position where s and t disagree.
/* strcmp: return <0 if s<t, 0 if s==t, >0 if s>t */
int strcmp(char *s, char *t)
{
int i;
for (i = 0; s[i] == t[i]; i++)
if (s[i] == '\0')
return 0;
return s[i] - t[i];
}
The pointer version of strcmp:
/* strcmp: return <0 if s<t, 0 if s==t, >0 if s>t */
int strcmp(char *s, char *t)
{
for ( ; *s == *t; s++, t++)
if (*s == '\0')
return 0;
return *s - *t;
}
Since ++ and -- are either prefix or postfix operators, other
combinations of * and ++ and -- occur, although less
frequently. For example,
*--p
decrements p before fetching the character that p points to.
In fact, the pair of expressions
*p++ = val; /* push val onto stack */
val = *--p; /* pop top of stack into val */
are the standard idiom for pushing and popping a stack; see
Section 4.3.
The header <string.h> contains declarations for the functions mentioned in this section, plus a variety of other string-handling functions from the standard library.
Exercise 5-3. Write a pointer version of the function strcat that we showed in Chapter 2: strcat(s,t) copies the string t to the end of s.
Exercise 5-4. Write the function strend(s,t), which returns 1 if the string t occurs at the end of the string s, and zero otherwise.
Exercise 5-5. Write versions of the library functions strncpy, strncat, and strncmp, which operate on at most the first n characters of their argument strings. For example, strncpy(s,t,n) copies at most n characters of t to s. Full descriptions are in Appendix B.
Exercise 5-6. Rewrite appropriate programs from earlier chapters and exercises with pointers instead of array indexing. Good possibilities include getline (Chapters 1 and 4), atoi, itoa, and