Increment and Decrement Operators

   

C provides two unusual operators for incrementing and decrementing variables. The increment operator ₊₊ adds 1 to its operand, while the decrement operator _-- subtracts 1. We have frequently used ₊₊ to increment variables, as in 

   if (c == '\n')

       ++nl;

The unusual aspect is that ₊₊ and _-- may be used either as prefix operators (before the variable, as in _++n), or postfix operators (after the variable: _n++). In both cases, the effect is to increment _n. But the expression _++n increments _n before its value is used, while _n++ increments _n after its value has been used. This means that in a context where the value is being used, not just the effect, _++n and _n++ are different. If _n is 5, then 

    x = n++;

sets _x to 5, but 

    x = ++n;

sets _x to 6. In both cases, _n becomes 6. The increment and decrement operators can only be applied to variables; an expression like _(i+j)++ is illegal. 

In a context where no value is wanted, just the incrementing effect, as in 

    if (c == '\n')        nl++;

prefix and postfix are the same. But there are situations where one or the other is specifically called for. For instance, consider the function _squeeze(s,c), which removes all occurrences of the character _c from the string _s. 

   /* squeeze:  delete all c from s */    void squeeze(char s[], int c)

   {

      int i, j;

      for (i = j = 0; s[i] != '\0'; i++)           if (s[i] != c)               s[j++] = s[i];       s[j] = '\0';

   }

Each time a non-_c occurs, it is copied into the current _j position, and only then is _j incremented to be ready for the next character. This is exactly equivalent to 

    if (s[i] != c) {        s[j] = s[i];        j++;    }

Another example of a similar construction comes from the _getline function that we wrote in A Tutorial Introduction, where we can replace 

   if (c == '\n') {        s[i] = c;

       ++i;    } by the more compact 

    if (c == '\n')       s[i++] = c;

As a third example, consider the standard function _strcat(s,t), which concatenates the string _t to the end of string _s. _strcat assumes that there is enough space in _s to hold the combination. As we have written it, _strcat returns no value; the standard library version returns a pointer to the resulting string. 

   /* strcat:  concatenate t to end of s; s must be big enough */    void strcat(char s[], char t[])

   {

       int i, j;

       i = j = 0;

       while (s[i] != '\0') /* find end of s */            i++;

       while ((s[i++] = t[j++]) != '\0') /* copy t */

           ;    }

As each member is copied from _t to _s, the postfix ₊₊ is applied to both _i and _j to make sure that they are in position for the next pass through the loop. 

Revison . Write an alternative version of _{squeeze(s1,s2)} that deletes each character in s1 that matches any character in the string _s2. 

Revison . Write the function _any(s1,s2), which returns the first location in a string _s1 where any character from the string _s2 occurs, or _-1 if _s1 contains no characters from _s2.

(The standard library function _strpbrk does the same job but returns a pointer to the location.)