Next: Pointer Arithmetic Drawbacks, Previous: Low-Level Pointer Arithmetic, Up: Pointers [Contents][Index]

The ‘`++`’ operator adds 1 to a variable. We have seen it for
integers (see Increment/Decrement), but it works for pointers too.
For instance, suppose we have a series of positive integers,
terminated by a zero, and we want to add them up. Here is a simple
way to step forward through the array by advancing a pointer.

int sum_array_till_0 (int *p) { int sum = 0; for (;;) { /* Fetch the next integer. */ int next = *p++; /* Exit the loop if it’s 0. */ if (next == 0) break; /* Add it into running total. */ sum += next; } return sum; }

The statement ‘`break;`’ will be explained further on (see break Statement). Used in this way, it immediately exits the surrounding
`for`

statement.

`*p++`

uses postincrement (`++`

;
see Postincrement/Postdecrement) on the pointer `p`

. that
expression parses as `*(p++)`

, because a postfix operator always
takes precedence over a prefix operator. Therefore, it dereferences
the entering value of `p`

, then increments `p`

afterwards.

Incrementing a variable means adding 1 to it, as in `p = p + 1`

.
Since `p`

is a pointer, adding 1 to it advances it by the width
of the datum it points to—in this case, `sizeof (int)`

.
Therefore, each iteration of the loop picks up the next integer from
the series and puts it into `next`

.

This `for`

-loop has no initialization expression since `p`

and `sum`

are already initialized, has no end-test since the
‘`break;`’ statement will exit it, and needs no expression to
advance it since that’s done within the loop by incrementing `p`

and `sum`

. Thus, those three expressions after `for`

are
left empty.

Another way to write this function is by keeping the parameter value unchanged and using indexing to access the integers in the table.

int sum_array_till_0_indexing (int *p) { int i; int sum = 0; for (i = 0; ; i++) { /* Fetch the next integer. */ int next = p[i]; /* Exit the loop if it’s 0. */ if (next == 0) break; /* Add it into running total. */ sum += next; } return sum; }

In this program, instead of advancing `p`

, we advance `i`

and add it to `p`

. (Recall that `p[i]`

means ```
*(p +
i)
```

.) Either way, it uses the same address to get the next integer.

It makes no difference in this program whether we write `i++`

or
`++i`

, because the value *of that expression* is not used.
We use it for its effect, to increment `i`

.

The ‘`--`’ operator also works on pointers; it can be used
to step backwards through an array, like this:

int after_last_nonzero (int *p, int len) { /* Set up`q`

to point just after the last array element. */ int *q = p + len; while (q != p) /* Step`q`

back until it reaches a nonzero element. */ if (*--q != 0) /* Return the index of the element after that nonzero. */ return q - p + 1; return 0; }

That function returns the length of the nonzero part of the array specified by its arguments; that is, the index of the first zero of the run of zeros at the end.