Difference between revisions of "cpp/language/operator incdec"

Revision as of 08:29, 10 May 2013

Increment/decrement operators increments or decrements the value of the object.

Operator name	Syntax	Overloadable	Prototype examples (for class T)
Operator name	Syntax	Overloadable	Inside class definition	Outside class definition
pre-increment	`++a`	Yes	T& T::operator++();	T& operator++(T& a);
pre-decrement	`--a`	Yes	T& T::operator--();	T& operator--(T& a);
post-increment	`a++`	Yes	T T::operator++(int);	T operator++(T& a, int);
post-decrement	`a--`	Yes	T T::operator--(int);	T operator--(T& a, int);
Notes Prefix forms of the built-in operators return references and postfix forms return values, and typical user-defined overloads follow the pattern so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including void). The int parameter is a dummy parameter used to differentiate between pre- and post- in versions of the operators. When the user-defined postfix operator is called, the value passed in that parameter is always zero, although it may be changed by calling the operator using function call notation, e.g. a.operator++(2).

The operand of a built-in prefix increment or decrement operator must be a modifiable lvalue (non-const reference) of non-boolean arithmetic type or pointer to complete object type. For these operands, the expression ++x is exactly equivalent to x+=1, and the expression --x is exactly equivalent to x-=1, that is, the result is the updated operand, returned as lvalue, and all arithmetic conversion rules and pointer arithmetic rules defined for arithmetic operators apply.

If the operand of the preincrement operator is of type bool, it is set to true (deprecated).

Built-in postfix 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: Template:ddcl list begin <tr class="t-dcl ">

A operator++(A&, int)

</td>

<td >

bool operator++(bool&, int)

</td>

<td class="t-dcl-nopad"> </td> <td > (deprecated) </td> </tr> <tr class="t-dcl ">

P operator++(P&, int)

</td>

A operator--(A&, int)

</td>

P operator--(P&, int)

</td>

<td class="t-dcl-nopad"> </td> <td class="t-dcl-nopad"> </td> </tr> Template:ddcl list end

The operand of a built-in postfix increment or decrement operator must be a modifiable lvalue (non-const reference) of non-boolean arithmetic type or pointer to complete object type. The result is a prvalue, which is a copy the original value of the operand. As a side-effect, this operator modifies the value of its argument arg as if by evaluating arg += 1 or arg -= 1, for increment and decrement respectively. All arithmetic conversion rules and pointer arithmetic rules defined for arithmetic operators apply.

If the operand of the postincrement operator is of type bool, it is set to true (deprecated).

Example

Run this code

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

Output:

n = 5
n2 = 2
n3 = 4
n4 = 4

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 the operation, pre-increment or pre-decrement operators are usually more efficient in contexts where the returned value is not used.

Standard library

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

Template:cpp/atomic/atomic/dcl list operator arith

overloads for arithmetic types
operator++operator++(int)operator--operator--(int)	increments or decrements the tick count (public member function of `std::chrono::duration<Rep,Period>`)
overloads for iterator types
operator++operator++(int)	advances the iterator (public member function of `std::raw_storage_iterator<OutputIt,T>`)
operator++operator++(int)	advances the iterator (public member function of `std::reverse_iterator<Iter>`)
operator--operator++(int)	decrements the iterator (public member function of `std::reverse_iterator<Iter>`)
operator++operator++(int)	no-op (public member function of `std::back_insert_iterator<Container>`)
operator++operator++(int)	no-op (public member function of `std::front_insert_iterator<Container>`)
operator++operator++(int)	no-op (public member function of `std::insert_iterator<Container>`)
operator++operator++(int)	advances the iterator (public member function of `std::move_iterator<Iter>`)
operator--operator--(int)	decrements the iterator (public member function of `std::move_iterator<Iter>`)
operator++operator++(int)	advances the istream_iterator (public member function of `std::istream_iterator<T,CharT,Traits,Distance>`)
operator++operator++(int)	no-op (public member function of `std::ostream_iterator<T,CharT,Traits>`)
operator++operator++(int)	advances the istreambuf_iterator (public member function of `std::istreambuf_iterator<CharT,Traits>`)
operator++operator++(int)	no-op (public member function of `std::ostreambuf_iterator<CharT,Traits>`)
operator++operator++(int)	advances the regex_iterator (public member function of `std::regex_iterator<BidirIt,CharT,Traits>`)
operator++operator++(int)	advances the regex_token_iterator (public member function of `std::regex_token_iterator<BidirIt,CharT,Traits>`)

@@ Line 118: / Line 118: @@
 {{dcl list h2 | overloads for iterator types}}
 {{dcl list mem fun | cpp/memory/raw_storage_iterator/operator++ | title=operator++<br>operator++{{dcl small|(int)}} | advances the iterator}}
-{{dcl list mem fun | cpp/iterator/reverse_iterator/operator++ | title=operator++<br>operator++{{dcl small|(int)}} | advances the iterator }}
+{{dcl list mem fun | cpp/iterator/reverse_iterator/operator_arith | title=operator++<br>operator++{{dcl small|(int)}} | advances the iterator }}
-{{dcl list mem fun | cpp/iterator/reverse_iterator/operator-- | title=operator--<br>operator++{{dcl small|(int)}} | decrements the iterator }}
+{{dcl list mem fun | cpp/iterator/reverse_iterator/operator_arith | title=operator--<br>operator++{{dcl small|(int)}} | decrements the iterator }}
 {{dcl list mem fun | cpp/iterator/back_insert_iterator/operator++ | title=operator++<br>operator++{{dcl small|(int)}} | no-op }}
 {{dcl list mem fun | cpp/iterator/front_insert_iterator/operator++ | title=operator++<br>operator++{{dcl small|(int)}} | no-op }}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Common operators
assignment	increment decrement	arithmetic	logical	comparison	member access	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 a->b a.b a->b a.*b	function call
						a(...)
						comma
						a, b
						conditional
						a ? b : c
Special operators
`static_cast` converts one type to another related type `dynamic_cast` converts within inheritance hierarchies `const_cast` adds or removes cv-qualifiers `reinterpret_cast` converts type to unrelated type C-style cast converts one type to another by a mix of `static_cast`, `const_cast`, and `reinterpret_cast` `new` creates objects with dynamic storage duration `delete` destructs objects previously created by the new expression and releases obtained memory area `sizeof` queries the size of a type `sizeof...` queries the size of a parameter pack (since C++11) `typeid` queries the type information of a type `noexcept` checks if an expression can throw an exception (since C++11) `alignof` queries alignment requirements of a type (since C++11)

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/language/operator incdec"

Revision as of 08:29, 10 May 2013

Contents

Explanation

Built-in prefix operators

Built-in postfix operators

Example

Notes

Standard library

overloads for arithmetic types

overloads for iterator types

See also

Navigation

Toolbox