Increment/decrement operators - cppreference.com (original) (raw)
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 old 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
See arithmetic operators for limitations on pointer arithmetic, as well as for implicit conversions applied to the operands.
[edit] 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.
[edit] Example
#include <stdio.h> #include <stdlib.h> int main(void) { int a = 1; int b = 1; printf("original values: a == %d, b == %d\n", a, b); printf("result of postfix operators: a++ == %d, b-- == %d\n", a++, b--); printf("after postfix operators applied: a == %d, b == %d\n", a, b); printf("\n"); // Reset a and b. a = 1; b = 1; printf("original values: a == %d, b == %d\n", a, b); printf("result of prefix operators: ++a == %d, --b == %d\n", ++a, --b); printf("after prefix operators applied: a == %d, b == %d\n", a, b); }
Output:
original values: a == 1, b == 1 result of postfix operators: a++ == 1, b-- == 1 after postfix operators applied: a == 2, b == 0 original values: a == 1, b == 1 result of prefix operators: ++a == 2, --b == 0 after prefix operators applied: a == 2, b == 0
[edit] References
C23 standard (ISO/IEC 9899:2024):
6.5.2.4 Postfix increment and decrement operators (p: TBD)
6.5.3.1 Prefix increment and decrement operators (p: TBD)
C17 standard (ISO/IEC 9899:2018):
6.5.2.4 Postfix increment and decrement operators (p: TBD)
6.5.3.1 Prefix increment and decrement operators (p: TBD)
C11 standard (ISO/IEC 9899:2011):
6.5.2.4 Postfix increment and decrement operators (p: 85)
6.5.3.1 Prefix increment and decrement operators (p: 88)
C99 standard (ISO/IEC 9899:1999):
6.5.2.4 Postfix increment and decrement operators (p: 75)
6.5.3.1 Prefix increment and decrement operators (p: 78)
C89/C90 standard (ISO/IEC 9899:1990):
3.3.2.4 Postfix increment and decrement operators
3.3.3.1 Prefix increment and decrement operators
[edit] See also
Common operators | ||||||
---|---|---|---|---|---|---|
assignment | incrementdecrement | arithmetic | logical | comparison | member access | other |
a = ba += ba -= ba *= ba /= ba %= ba &= ba |= ba ^= ba <<= ba >>= b | ++a --aa++a-- | +a -aa + ba - ba * ba / ba % b~aa & ba | ba ^ ba << ba >> b | !aa && ba | | b | a == ba != ba < ba > ba <= ba >= b | a[b] *a &aa->ba.b |