# Increment/decrement operators

> C++ Atlas: `cppatlas.com/w/c/language/operator_incdec` | Source: https://en.cppreference.com/w/c/language/operator_incdec | Domain: Language | Standards: C11, C23

Increment/decrement operators are unary operators that increment/decrement the value of a variable by 1.

## Official Specification Summary (cppreference)

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.

```c
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
```

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.

### Example

```c
#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:

```text
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
```

### 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

### See also

[Operator precedence](https://en.cppreference.com/w/c/language/operator_precedence)

| Common operators |   |   |   |   |   |   |
| --- | --- | --- | --- | --- | --- | --- |
| [assignment](https://en.cppreference.com/w/c/language/operator_assignment) | **increment decrement** | [arithmetic](https://en.cppreference.com/w/c/language/operator_arithmetic) | [logical](https://en.cppreference.com/w/c/language/operator_logical) | [comparison](https://en.cppreference.com/w/c/language/operator_comparison) | [member access](https://en.cppreference.com/w/c/language/operator_member_access) | [other](https://en.cppreference.com/w/c/language/operator_other) |
| `a = b a += b a -= b a *= b a /= b a %= b a &= b a \|= b a ^= b a <<= b a >>= b` | `++a --a a++ a--` | `+a -a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b` | `!a a && b a \|\| b` | `a == b a != b a < b a > b a <= b a >= b` | `a[b] *a &a a->b a.b` | `a(...) a, b (type) a a ? b: c sizeof` `_Alignof` (since C11) (until C23) `alignof` (since C23) |

- [C++ documentation for Increment/decrement operators](https://en.cppreference.com/w/cpp/language/operator_incdec)

---
Attribution: content from https://en.cppreference.com/w/c/language/operator_incdec (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.