Increment and decrement operators


Increment and decrement operators are unary operators that add or subtract one, to or from their operand, respectively. They are commonly implemented in imperative programming languages. C-like languages feature two versions of each operator with slightly different semantics.
In languages syntactically derived from B, the increment operator is written as ++ and the decrement operator is written as --. Several other languages use inc and dec functions.
The increment operator increases, and the decrement operator decreases, the value of its operand by 1. The operand must have an arithmetic or pointer data type, and must refer to a modifiable data object. Pointers values are increased by an amount that makes them point to the next element adjacent in memory.
In languages that support both versions of the operators:

In languages where increment/decrement is not an expression, only one version is needed.
Since the increment/decrement operator modifies its operand, use of such an operand more than once within the same expression can produce undefined results. For example, in expressions such as x - ++x, it is not clear in what sequence the subtraction and increment operations should be performed. Such expressions generally invoke undefined behavior, and should be avoided.

Examples

The following C code fragment illustrates the difference between the pre and post increment and decrement operators:

int x;
int y;
// Increment operators
// Pre-increment - x is incremented by 1, then y is assigned the value of x
x = 1;
y = ++x; // x is now 2, y is also 2
// Post-increment - y is assigned the value of x, then x is incremented by 1
x = 1;
y = x++; // x is now 2, y is 1
// Decrement operators
// Pre-decrement - x is decremented by 1, then y is assigned the value of x
x = 1;
y = --x; // x is now 0, y is also 0
// Post-decrement - y is assigned the value of x, then x is decremented by 1
x = 1;
y = x--; // x is now 0, y is 1

In languages lacking these operators, equivalent results require an extra line of code:

  1. Pre-increment: y = ++x
x = 1
x = x + 1 # x is now 2
y = x # y is also 2
  1. Post-increment: y = x++
x = 1
y = x # y is 1
x = x + 1 # x is now 2

The post-increment operator is commonly used with array subscripts. For example:

// Sum the elements of an array
float sum_elements

The post-increment operator is also commonly used with pointers:

// Copy one array to another
void copy_array

Note that these examples also work in other C-like languages, such as C++, Java, and C#.
  1. include
int main

Supporting languages

The following list, though not complete or all-inclusive, lists some of the major programming languages that support the ++/-- increment/decrement operators.
Pascal, Delphi, Modula-2, and Oberon provide the same functions, but they are called inc and dec.

History

The concept was introduced in the B programming language circa 1969 by Ken Thompson.
Thompson went a step further by inventing the ++ and -- operators, which increment or decrement; their prefix or postfix position determines whether the alteration occurs before or after noting the value of the operand. They were not in the earliest versions of B, but appeared along the way. People often guess that they were created to use the auto-increment and auto-decrement address modes provided by the DEC PDP-11 on which C and Unix first became popular. This is historically impossible, since there was no PDP-11 when B was developed. The PDP-7, however, did have a few 'auto-increment' memory cells, with the property that an indirect memory reference through them incremented the cell. This feature probably suggested such operators to Thompson; the generalization to make them both prefix and postfix was his own. Indeed, the auto-increment cells were not used directly in implementation of the operators, and a stronger motivation for the innovation was probably his observation that the translation of ++x was smaller than that of x=x+1.