### 14.13 Pointer Increment and Decrement ¶

The ‘`++`’ operator adds 1 to a variable. We have seen it for integers (see Increment and Decrement Operators), 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 and 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.