Increment/decrement operators - cppreference.com (original) (raw)

Increment/decrement operators increment or decrement the value of the object.

Contents

• 1 Prefix operators
  • 1.1 Built-in prefix operators
  • 1.2 Overloads
• 2 Postfix operators
  • 2.1 Built-in postfix operators
  • 2.2 Overloads
  • 2.3 Example
• 3 Notes
• 4 Standard library
  • 4.1 overloads for arithmetic types
  • 4.2 overloads for iterator types
• 5 Defect reports
• 6 See also

[edit] Prefix operators

The prefix increment and decrement expressions have the form

| | | | | ------------------ | | | | ++ expression | | | | | | | | -- expression | | | | | | |

1. prefix increment (pre-increment)

2. prefix decrement (pre-decrement)

[edit] Built-in prefix operators

1. The expression ++x is equivalent to x += 1, with the following exceptions:

1. The expression --x is equivalent to x -= 1, with the following exceptions:

• If the type of expression is (possibly cv-qualified) bool, the program is ill-formed.

[edit] Overloads

In overload resolution against user-defined operators, for every optionally volatile-qualified arithmetic type A other than bool, and for every optionally volatile-qualified pointer P to optionally cv-qualified object type, the following function signatures participate in overload resolution:

| A& operator++(A&) | | | | ----------------------- | | ------------------------- | | bool& operator++(bool&) | | (deprecated)(until C++17) | | P& operator++(P&) | | | | A& operator--(A&) | | | | P& operator--(P&) | | |

[edit] Postfix operators

The postfix increment and decrement expressions have the form

| | | | | ------------------ | | | | expression ++ | | | | | | | | expression -- | | | | | | |

1. postfix increment (post-increment)

2. postfix decrement (post-decrement)

[edit] Built-in postfix operators

The result of postfix increment or decrement is the value obtained by applying the lvalue-to-rvalue conversion to expression (before modification). The type of the result is the cv-unqualified version of the type of expression.

If expression is not a modifiable lvalue of an arithmetic type other than (possibly cv-qualified) bool(since C++17), or a pointer to a complete object type, the program is ill-formed.

1. The value of expression is modified as if it were the operand of the prefix ++ operator.

2. The value of expression is modified as if it were the operand of the prefix -- operator.

The value computation of a postfix increment or decrement is sequenced before the modification of expression. With respect to an indeterminately-sequenced function call, the operation of a postfix increment or decrement is a single evaluation.

[edit] Overloads

In overload resolution against user-defined operators, for every optionally volatile-qualified arithmetic type A other than bool, and for every optionally volatile-qualified pointer P to optionally cv-qualified object type, the following function signatures participate in overload resolution:

| A operator++(A&, int) | | | | --------------------------- | | ------------------------- | | bool operator++(bool&, int) | | (deprecated)(until C++17) | | P operator++(P&, int) | | | | A operator--(A&, int) | | | | P operator--(P&, int) | | |

[edit] Example

#include   int main() { int n1 = 1; int n2 = ++n1; int n3 = ++ ++n1; int n4 = n1++; // int n5 = n1++ ++; // error // int n6 = n1 + ++n1; // undefined behavior std::cout << "n1 = " << n1 << '\n' << "n2 = " << n2 << '\n' << "n3 = " << n3 << '\n' << "n4 = " << n4 << '\n'; }

Output:

n1 = 5 n2 = 2 n3 = 4 n4 = 4

[edit] Notes

Because of the side-effects involved, built-in increment and decrement operators must be used with care to avoid undefined behavior due to violations of sequencing rules.

Because a temporary copy of the object is constructed during post-increment and post-decrement, pre-increment or pre-decrement operators are usually more efficient in contexts where the returned value is not used.

[edit] Standard library

Increment and decrement operators are overloaded for many standard library types. In particular, every LegacyIterator overloads operator++ and every LegacyBidirectionalIterator overloads operator--, even if those operators are no-ops for the particular iterator.

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

1. ↑ The prefix ++x is equivalent to x += 1, and the latter is applicable for usual arithmetic conversions (i.e. yield a common type between decltype(x) and int). However, the effect of the postfix x++ is simply “adding one to x”, there is no binary operator present, so no usual arithmetic conversions will take place.

[edit] See also

Operator precedence

Operator overloading