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 cvrqualified, 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 sideeffect of adding the value 1
of appropriate type to the operand. Decrement operators initiate the sideeffect of subtracting the value 1
of appropriate type from the operand. As with any other sideeffects, 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
.
Postincrement or postdecrement on any atomic variable is an atomic readmodifywrite operation with memory order  (since C11) 
See arithmetic operators for limitations on pointer arithmetic, as well as for implicit conversions applied to the operands.
Because of the sideeffects 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.
#include <stdlib.h> #include <stdio.h> int main(void) { int a = 1; int b = 1; printf("\n"); 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); // Reset a and b. a = 1; b = 1; printf("\n"); 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
Common operators  

assignment  increment decrement  arithmetic  logical  comparison  member access  other 







C++ documentation for Increment/decrement operators 
© cppreference.com
Licensed under the Creative Commons AttributionShareAlike Unported License v3.0.
https://en.cppreference.com/w/c/language/operator_incdec