Returns the result of specific arithmetic operation.

[edit]General explanation

All built-in arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments are not modified.

[edit]Conversions

If the operand passed to a built-in arithmetic operator is integral or unscoped enumeration type, then before any other action (but after lvalue-to-rvalue conversion, if applicable), the operand undergoesintegral promotion. If an operand has array or function type,array-to-pointer andfunction-to-pointer conversions are applied.

For the binary operators (except shifts), if the promoted operands have different types,usual arithmetic conversions are applied.

[edit]Overflows

Unsigned integer arithmetic is always performedmodulo 2n
where n is the number of bits in that particular integer. E.g. forunsignedint, adding one toUINT_MAX gives​0​, and subtracting one from​0​ givesUINT_MAX.

When signed integer arithmetic operation overflows (the result does not fit in the result type), the behavior is undefined, — the possible manifestations of such an operation include:

• it wraps around according to the rules of the representation (typicallytwo's complement),
• it traps — on some platforms or due to compiler options (e.g.-ftrapv in GCC and Clang),
• it saturates to minimal or maximal value (on many DSPs),
• it is completelyoptimized out by the compiler.

[edit]Floating-point environment

If#pragma STDC FENV_ACCESS is supported and set toON, all floating-point arithmetic operators obey the current floating-pointrounding direction and report floating-point arithmetic errors as specified inmath_errhandling unless part of astatic initializer (in which case floating-point exceptions are not raised and the rounding mode is to nearest).

[edit]Floating-point contraction

Unless#pragma STDC FP_CONTRACT is supported and set toOFF, all floating-point arithmetic may be performed as if the intermediate results have infinite range and precision, that is, optimizations that omit rounding errors and floating-point exceptions are allowed. For example, C++ allows the implementation of(x* y)+ z with a single fused multiply-add CPU instruction or optimization ofa= x* x* x* x; astmp= x* x; a= tmp* tmp.

Unrelated to contracting, intermediate results of floating-point arithmetic may have range and precision that is different from the one indicated by its type, seeFLT_EVAL_METHOD.

Formally, the C++ standard makes no guarantee on the accuracy of floating-point operations.

[edit]Unary arithmetic operators

The unary arithmetic operator expressions have the form

Unary+ and- operators have higherprecedence than all binary arithmetic operators, soexpression cannot contain top-level binary arithmetic operators. These operators associate from right to left:

+a- b;// equivalent to (+a) - b, NOT +(a - b)-c+ d;// equivalent to (-c) + d, NOT -(c + d) +-e;// equivalent to +(-e), the unary + is a no-op if “e” is a built-in type// because any possible promotion is performed during negation already

[edit]Built-in unary arithmetic operators

[edit]Overloads

Inoverload resolution against user-defined operators, for every cv-unqualified promoted arithmetic typeA and for every typeT, the following function signatures participate in overload resolution:

#include <iostream> int main(){char c=0x6a;int n1=1;unsignedchar n2=1;unsignedint n3=1;std::cout<<"char: "<< c<<" int: "<<+c<<"\n""-1, where 1 is signed: "<<-n1<<"\n""-1, where 1 is unsigned char: "<<-n2<<"\n""-1, where 1 is unsigned int: "<<-n3<<'\n';char a[3];std::cout<<"size of array: "<< sizeof a<<"\n""size of pointer: "<< sizeof+a<<'\n';}

char: j int: 106-1, where 1 is signed: -1-1, where 1 is unsigned char: -1-1, where 1 is unsigned int: 4294967295size of array: 3size of pointer: 8

[edit]Additive operators

The additive operator expressions have the form

Binary+ and- operators have higherprecedence than all other binary arithmetic operators except*,/ and%. These operators associate from left to right:

a+ b* c;// equivalent to a + (b * c),  NOT (a + b) * cd/ e- f;// equivalent to (d / e) - f,  NOT d / (e - f)g+ h>> i;// equivalent to (g + h) >> i, NOT g + (h >> i) j- k+ l- m;// equivalent to ((j - k) + l) - m

[edit]Built-in additive operators

For built-in binary plus and binary minus operators, both oflhs andrhs must be prvalues, and one of the following conditions must be satisfied:

• Both operands have arithmetic or unscoped enumeration type. In this case,usual arithmetic conversions are performed on both operands.
• Exactly one operand has integral or unscoped enumeration type. In this case, integral promotion is applied to that operand.

In the remaining description in this section, "operand(s)",lhs andrhs refer to the converted or promoted operand(s).

If both operands have a floating-point type, and the type supports IEEE floating-point arithmetic (seestd::numeric_limits::is_iec559):

• If one operand is NaN, the result is NaN.
• Infinity minus infinity is NaN, andFE_INVALID is raised.
• Infinity plus the negative infinity is NaN, andFE_INVALID is raised.

[edit]Pointer arithmetic

When an expressionJ that has integral type is added to or subtracted from an expressionP of pointer type, the result has the type ofP.

• IfP evaluates to anull pointer value andJ evaluates to​0​, the result is a null pointer value.
• Otherwise, ifP points to theith element of an array objectx withn elements, given the value ofJ asj,P is added or subtracted as follows:

• The expressionsP+ J andJ+ P

• point to thei+jth element ofx ifi+ j is in[​0​, n), and
• are pointers past the end of the last element ofx ifi+ j isn.

• The expressionP- J

• points to thei-jth element ofx ifi- j is in[​0​, n), and
• is a pointer past the end of the last element ofx ifi- j isn.

• Otherj values result in undefined behavior.

• Otherwise, ifP points to a complete object, a base class subobject or a member subobjecty, given the value ofJ asj,P is added or subtracted as follows:

• The expressionsP+ J andJ+ P

• point toy ifj is​0​, and
• are pointers past the end ofy ifj is1.

• The expressionP- J

• points toy ifj is​0​, and
• is a pointer past the end ofy ifj is-1.

• Otherj values result in undefined behavior.

• Otherwise, ifP is a pointer past the end of an objectz, given the value ofJ asj:

• Ifz is an array object withn elements,P is added or subtracted as follows:

• The expressionsP+ J andJ+ P

• point to then+jth element ofz ifn+ j is in[​0​, n), and
• are pointers past the end of the last element ofz ifj is​0​.

• The expressionP- J

• points to then-jth element ofz ifn- j is in[​0​, n), and
• is a pointer past the end of the last element ofz ifj is​0​.

• Otherj values result in undefined behavior.

• Otherwise,P is added or subtracted as follows:

• The expressionsP+ J andJ+ P

• point toz ifj is-1, and
• are pointers past the end ofz ifj is​0​.

• The expressionP- J

• points toz ifj is1, and
• is a pointer past the end ofz ifj is​0​.

• Otherj values result in undefined behavior.

• Otherwise, the behavior is undefined.

When two pointer expressionsP andQ are subtracted, the type of the result isstd::ptrdiff_t.

• IfP andQ both evaluate tonull pointer values, the result is​0​.
• Otherwise, ifP andQ point to, respectively, theith andjth array elements of the same array objectx, the expressionP- Q has the valuei − j.

• Ifi − j is not representable bystd::ptrdiff_t, the behavior is undefined.

• Otherwise, ifP andQ point to the same complete object, base class subobject or member subobject, the result is​0​.
• Otherwise, the behavior is undefined.

These pointer arithmetic operators allow pointers to satisfy theLegacyRandomAccessIterator requirements.

For addition and subtraction, ifP orQ have type “pointer to (possibly cv-qualified)T”, whereT and the array element type are notsimilar, the behavior is undefined:

int arr[5]={1,2,3,4,5};unsignedint*p=reinterpret_cast<unsignedint*>(arr+1);unsignedint k=*p;// OK, the value of “k” is 2unsignedint*q= p+1;// undefined behavior: “p” points to int, not unsigned int

[edit]Overloads

Inoverload resolution against user-defined operators, for every pair of promoted arithmetic typesL andR and for every object typeT, the following function signatures participate in overload resolution:

whereLR is the result ofusual arithmetic conversions onL andR.

#include <iostream> int main(){char c=2;unsignedint un=2;int n=-10;std::cout<<" 2 + (-10), where 2 is a char    = "<< c+ n<<"\n"" 2 + (-10), where 2 is unsigned  = "<< un+ n<<"\n"" -10 - 2.12  = "<< n-2.12<<'\n'; char a[4]={'a','b','c','d'};char* p=&a[1];std::cout<<"Pointer addition examples: "<<*p<<*(p+2)<<*(2+ p)<<*(p-1)<<'\n';char* p2=&a[4];std::cout<<"Pointer difference: "<< p2- p<<'\n';}

 2 + (-10), where 2 is a char    = -8 2 + (-10), where 2 is unsigned  = 4294967288 -10 - 2.12  = -12.12Pointer addition examples: bddaPointer difference: 3

[edit]Multiplicative operators

The multiplicative operator expressions have the form

Multiplicative operators have higherprecedence than all other binary arithmetic operators. These operators associate from left to right:

a+ b* c;// equivalent to a + (b * c),  NOT (a + b) * cd/ e- f;// equivalent to (d / e) - f,  NOT d / (e - f)g% h>> i;// equivalent to (g % h) >> i, NOT g % (h >> i) j* k/ l% m;// equivalent to ((j * k) / l) % m

[edit]Built-in multiplicative operators

For built-in multiplication and division operators, both operands must have arithmetic or unscoped enumeration type. For the built-in remainder operator, both operands must have integral or unscoped enumeration type.Usual arithmetic conversions are performed on both operands.

In the remaining description in this section, "operand(s)",lhs andrhs refer to the converted operand(s).

Note: UntilCWG issue 614 was resolved (N2757), if one or both operands to binary operator % were negative, the sign of the remainder was implementation-defined, as it depends on the rounding direction of integer division. The functionstd::div provided well-defined behavior in that case.

Note: for floating-point remainder, seestd::remainder andstd::fmod.

[edit]Overloads

Inoverload resolution against user-defined operators, for every pair of promoted arithmetic typesLA andRA and for every pair of promoted integral typesLI andRI the following function signatures participate in overload resolution:

whereLRx is the result ofusual arithmetic conversions onLx andRx.

#include <iostream> int main(){char c=2;unsignedint un=2;int  n=-10;std::cout<<"2 * (-10), where 2 is a char    = "<< c* n<<"\n""2 * (-10), where 2 is unsigned  = "<< un* n<<"\n""-10 / 2.12  = "<< n/2.12<<"\n""-10 / 21  = "<< n/21<<"\n""-10 % 21  = "<< n%21<<'\n';}

2 * (-10), where 2 is a char    = -202 * (-10), where 2 is unsigned  = 4294967276-10 / 2.12  = -4.71698-10 / 21  = 0-10 % 21  = -10

[edit]Bitwise logic operators

The bitwise logic operator expressions have the form

The bitwise NOT operator has higherprecedence than all binary arithmetic operators. It associates from right to left:

~a- b;// equivalent to (~a) - b, NOT ~(a - b)~c* d;// equivalent to (~c) * d, NOT ~(c * d) ~-e;// equivalent to ~(-e)

There is an ambiguity in the grammar when~ is followed by atype name ordecltype specifier(since C++11): it can either be operator~ or start adestructor identifier). The ambiguity is resolved by treating~ as operator~.~ can start a destructor identifier only in places where forming an operator~ is syntactically invalid.

All other bitwise logic operators have lowerprecedence than all other binary arithmetic operators. Bitwise AND has higher precedence than bitwise XOR, which has higher precedence than bitwise OR. They associate from left to right:

a& b* c;// equivalent to a & (b * c),  NOT (a & b) * cd/ e^ f;// equivalent to (d / e) ^ f,  NOT d / (e ^ f)g<< h| i;// equivalent to (g << h) | i, NOT g << (h | i) j& k& l;// equivalent to (j & k) & lm| n^ o// equivalent to m | (n ^ o)

[edit]Built-in bitwise logic operators

For the built-in bitwise NOT operator,rhs must be a prvalue of integral or unscoped enumeration type, and integral promotion is performed onrhs. For other built-in bitwise logic operators, both operands must have integral or unscoped enumeration type, andusual arithmetic conversions are performed on both operands.

In the remaining description in this section, "operand(s)",lhs andrhs refer to the converted or promoted operand(s).

[edit]Overloads

Inoverload resolution against user-defined operators, for every pair of promoted integral typesL andR the following function signatures participate in overload resolution:

whereLR is the result ofusual arithmetic conversions onL andR.

#include <bitset>#include <cstdint>#include <iomanip>#include <iostream> int main(){std::uint16_t mask=0x00f0;std::uint32_t x0=0x12345678;std::uint32_t x1= x0| mask;std::uint32_t x2= x0& ~mask;std::uint32_t x3= x0& mask;std::uint32_t x4= x0^ mask;std::uint32_t x5= ~x0;using bin16=std::bitset<16>;using bin32=std::bitset<32>;std::cout<<std::hex<<std::showbase<<"Mask: "<< mask<<std::setw(49)<< bin16(mask)<<"\n""Value: "<< x0<<std::setw(42)<< bin32(x0)<<"\n""Setting bits: "<< x1<<std::setw(35)<< bin32(x1)<<"\n""Clearing bits: "<< x2<<std::setw(34)<< bin32(x2)<<"\n""Selecting bits: "<< x3<<std::setw(39)<< bin32(x3)<<"\n""XOR-ing bits: "<< x4<<std::setw(35)<< bin32(x4)<<"\n""Inverting bits: "<< x5<<std::setw(33)<< bin32(x5)<<'\n';}

Mask: 0xf0                                 0000000011110000Value: 0x12345678          00010010001101000101011001111000Setting bits: 0x123456f8   00010010001101000101011011111000Clearing bits: 0x12345608  00010010001101000101011000001000Selecting bits: 0x70       00000000000000000000000001110000XOR-ing bits: 0x12345688   00010010001101000101011010001000Inverting bits: 0xedcba987 11101101110010111010100110000111

[edit]Bitwise shift operators

The bitwise shift operator expressions have the form

Bitwise shift operators have higherprecedence than bitwise logic operators, but have lower precedence than additive and multiplicative operators. These operators associate from left to right:

a>> b* c;// equivalent to a >> (b * c),  NOT (a >> b) * cd<< e& f;// equivalent to (d << e) & f,  NOT d << (e & f) g<< h>> i;// equivalent to (g << h) >> i, NOT g << (h >> i)

[edit]Built-in bitwise shift operators

For the built-in bitwise shift operators, both operands must be prvalues of integral or unscoped enumeration type. Integral promotions are performed on both operands.

In the remaining description in this section, "operand(s)",a,b,lhs andrhs refer to the converted or promoted operand(s).

If the value ofrhs is negative or is not less than the number of bits inlhs, the behavior is undefined.

The type of the result is that oflhs.

[edit]Overloads

Inoverload resolution against user-defined operators, for every pair of promoted integral typesL andR, the following function signatures participate in overload resolution:

#include <iostream> enum{ ONE=1, TWO=2}; int main(){std::cout<<std::hex<<std::showbase;char c=0x10;unsignedlonglong ull=0x123;std::cout<<"0x123 << 1 = "<<(ull<<1)<<"\n""0x123 << 63 = "<<(ull<<63)<<"\n"// overflow in unsigned"0x10 << 10 = "<<(c<<10)<<'\n';// char is promoted to intlonglong ll=-1000;std::cout<<std::dec<<"-1000 >> 1 = "<<(ll>> ONE)<<'\n';}

0x123 << 1 = 0x2460x123 << 63 = 0x80000000000000000x10 << 10 = 0x4000-1000 >> 1 = -500

[edit]Standard library

Arithmetic operators are overloaded for many standard library types.

[edit]Unary arithmetic operators

[edit]Additive operators

[edit]Multiplicative operators

[edit]Bitwise logic operators

[edit]Bitwise shift operators

[edit]Stream insertion/extraction operators

Throughout the standard library, bitwise shift operators are commonly overloaded with I/O stream (std::ios_base& or one of the classes derived from it) as both the left operand and return type. Such operators are known asstream insertion andstream extraction operators:

[edit]Defect reports

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

[edit]See also

Operator precedence

Operator overloading

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文