Increment/decrement operators
Increment/decrement operators are unary operators that increment/decrement the value of a variable by 1.
They can have postfix form:
expr ++
|
|||||||||
expr --
|
|||||||||
As well as the prefix form:
++ expr
|
|||||||||
-- expr
|
|||||||||
The operand expr of both prefix and postfix increment or decrement must be a modifiable lvalue of integer type (including _Bool and enums), real floating type, or a pointer type. It may be cvr-qualified, unqualified, or atomic.
The result of the postfix increment and decrement operators is the value of expr.
The result of the prefix increment operator is the result of adding the value 1 to the value of expr: the expression ++e is equivalent to e+=1. The result of the prefix decrement operator is the result of subtracting the value 1 from the value of expr: the expression --e is equivalent to e-=1.
Increment operators initiate the side-effect of adding the value 1 of appropriate type to the operand. Decrement operators initiate the side-effect of subtracting the value 1 of appropriate type from the operand. As with any other side-effects, these operations complete at or before the next sequence point.
int a = 1;
int b = a++; // stores 1+a (which is 2) to a
// returns the value of a (which is 1)
// After this line, b == 1 and a == 2
a = 1;
int c = ++a; // stores 1+a (which is 2) to a
// returns 1+a (which is 2)
// after this line, c == 2 and a == 2
|
Post-increment or post-decrement on any atomic variable is an atomic read-modify-write operation with memory order memory_order_seq_cst. |
(since C11) |
See arithmetic operators for limitations on pointer arithmetic, as well as for implicit conversions applied to the operands.
Notes
Because of the side-effects involved, increment and decrement operators must be used with care to avoid undefined behavior due to violations of sequencing rules.
Increment/decrement operators are not defined for complex or imaginary types: the usual definition of adding/subtracting the real number 1 would have no effect on imaginary types, and making it add/subtract i for imaginaries but 1 for complex numbers would have made it handle 0+yi different from yi.
Unlike C++ (and some implementations of C), the increment/decrement expressions are never themselves lvalues: &++a is invalid.