Returns the result of specific arithmetic operation.
All built-in arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments are not modified.
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 undergoes
. If an operand has array or function type,
and
conversions are applied.
For the binary operators (except shifts), if the promoted operands have different types,
are applied.
Unsigned integer arithmetic is always performed modulo 2n
where n is the number of bits in that particular integer. E.g. for unsignedint, adding one to
gives 0, and subtracting one from 0 gives
.
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:
If
is supported and set to ON, all floating-point arithmetic operators obey the current floating-point
and report floating-point arithmetic errors as specified in
unless part of a
(in which case floating-point exceptions are not raised and the rounding mode is to nearest).
Unless
is supported and set to OFF, 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 of a=x*x*x*x; as tmp=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, see
.
Formally, the C++ standard makes no guarantee on the accuracy of floating-point operations.
1) Unary plus (promotion).
2) Unary minus (negation).
Unary + and - operators have higher
than all binary arithmetic operators, so expression cannot contain top-level binary arithmetic operators. These operators associate from right to left:
1) For the built-in unary plus operator, expression must be a prvalue of arithmetic, unscoped enumeration, or pointer type. Integral promotion is performed on expression if it has integral or unscoped enumeration type. The type of the result is the (possibly promoted) type of expression.
The result of the built-in promotion is the value of expression. The built-in unary operation is no-op if the operand is a prvalue of a promoted integral type or a pointer type. Otherwise, the type or value category of the operand is changed by integral promotion or lvalue-to-rvalue, array-to-pointer, function-to-pointer, or user-defined conversion. For example, char is converted to int, and non-generic captureless
is converted to function pointer(since C++11) in unary plus expressions.
2) For the built-in unary minus operator, expression must be a prvalue of arithmetic or unscoped enumeration type. Integral promotion is performed on expression. The type of the result is the type of the promoted type of expression.
The result of the built-in negation is the negative of the promoted expression. For unsigned a, the value of -a is 2N
-a, where N is the number of bits after promotion.
In other words, the result is the two’s complement of the operand (where operand and result are considered as unsigned).
Overloads
In
overload resolution against user-defined operators
, for every cv-unqualified promoted arithmetic type A and for every type T, the following function signatures participate in overload resolution:
Aoperator+(A)T*operator+(T*)Aoperator-(A)Run this code
#include<iostream>intmain(){charc=0x6a;intn1=1;unsignedcharn2=1;unsignedintn3=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';chara[3];std::cout<<"size of array: "<<sizeofa<<"\n""size of pointer: "<<sizeof+a<<'\n';}Possible output:
char: j int: 106 -1, where 1 is signed: -1 -1, where 1 is unsigned char: -1 -1, where 1 is unsigned int: 4294967295 size of array: 3 size of pointer: 8 Additive operators
The additive operator expressions have the form
lhs+rhs(1) lhs-rhs(2) 1) Binary plus (addition).
2) Binary minus (subtraction).
Binary + and - operators have higher
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) - mBuilt-in additive operators
For built-in binary plus and binary minus operators, both of lhs and rhs must be prvalues, and one of the following conditions must be satisfied:
Both operands have arithmetic or unscoped enumeration type. In this case,
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 and rhs refer to the converted or promoted operand(s).
1) For built-in addition, one of the following conditions must be satisfied:
Both operands have arithmetic type. In this case, the result is the sum of the operands.
One operand is a pointer to a completely-defined object type, and the other operand has integral type. In this case, the integral value is added to the pointer (see
).
2) For built-in subtraction, one of the following conditions must be satisfied:
Both operands have arithmetic type. In this case, the result is the difference resulting from the subtraction of rhs from lhs.
lhs is a pointer to a completely-defined object type, and rhs has integral type. In this case, the integral value is subtracted from the pointer (see
).
Both operands are pointers to cv-qualified or cv-unqualified versions of the same completely-defined object type. In this case rhs is subtracted from lhs (see
).
If both operands have a floating-point type, and the type supports IEEE floating-point arithmetic (see
std::numeric_limits::is_iec559
):
If one operand is NaN, the result is NaN.
Infinity minus infinity is NaN, and
is raised.
Infinity plus the negative infinity is NaN, and
is raised.
Pointer arithmetic
When an expression J that has integral type is added to or subtracted from an expression P of pointer type, the result has the type of P.
If P evaluates to a
and J evaluates to 0, the result is a null pointer value.
Otherwise, if P points to the ith element of an array object x with n elements, given the value of J as j, P is added or subtracted as follows:
The expressions P+J and J+P
point to the i+jth element of x if i+j is in [0, n), and
are pointers past the end of the last element of x if i+j is n.
The expression P-J
points to the i-jth element of x if i-j is in [0, n), and
is a pointer past the end of the last element of x if i-j is n.
Other j values result in undefined behavior.
Otherwise, if P points to a complete object, a base class subobject or a member subobject y, given the value of J as j, P is added or subtracted as follows:
The expressions P+J and J+P
point to y if j is 0, and
are pointers past the end of y if j is 1.
The expression P - J
points to y if j is 0, and
is a pointer past the end of y if j is -1.
Other j values result in undefined behavior.
Otherwise, if P is a pointer past the end of an object z, given the value of J as j:
If z is an array object with n elements, P is added or subtracted as follows:
The expressions P + J and J + P
point to the n+jth element of z if n + j is in [0, n), and
are pointers past the end of the last element of z if j is 0.
The expression P - J
points to the n-jth element of z if n - j is in [0, n), and
is a pointer past the end of the last element of z if j is 0.
Other j values result in undefined behavior.
Otherwise, P is added or subtracted as follows:
The expressions P + J and J + P
point to z if j is -1, and
are pointers past the end of z if j is 0.
The expression P - J
points to z if j is 1, and
is a pointer past the end of z if j is 0.
Other j values result in undefined behavior.
Otherwise, the behavior is undefined.
When two pointer expressions P and Q are subtracted, the type of the result is
.
If P and Q both evaluate to
, the result is 0.
Otherwise, if P and Q point to, respectively, the ith and jth array elements of the same array object x, the expression P - Q has the value i − j.
If i − j is not representable by
, the behavior is undefined.
Otherwise, if P and Q 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 the
requirements.
For addition and subtraction, if P or Q have type “pointer to (possibly cv-qualified) T”, where T and the array element type are not
, the behavior is undefined:
int arr[5] = {1, 2, 3, 4, 5}; unsigned int *p = reinterpret_cast<unsigned int*>(arr + 1); unsigned int k = *p; // OK, the value of “k” is 2 unsigned int *q = p + 1; // undefined behavior: “p” points to int, not unsigned intOverloads
In
overload resolution against user-defined operators
, for every pair of promoted arithmetic types L and R and for every object type T, the following function signatures participate in overload resolution:
LR operator+(L, R)LR operator-(L, R)T* operator+(T*, std::ptrdiff_t)T* operator+(std::ptrdiff_t, T*)T* operator-(T*, std::ptrdiff_t)std::ptrdiff_t operator-(T*, T*)where LR is the result of
on L and R.
Run this code
#include <iostream> int main() { char c = 2; unsigned int 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'; }Output:
2 + (-10), where 2 is a char = -8 2 + (-10), where 2 is unsigned = 4294967288 -10 - 2.12 = -12.12 Pointer addition examples: bdda Pointer difference: 3Multiplicative operators
The multiplicative operator expressions have the form
lhs*rhs(1) lhs/rhs(2) lhs%rhs(3) 1) Multiplication.
2) Division.
3) Remainder.
Multiplicative operators have higher
than all other binary arithmetic operators. These operators associate from left to right:
a + b * c; // equivalent to a + (b * c), NOT (a + b) * c d / 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) % mBuilt-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.
are performed on both operands.
In the remaining description in this section, "operand(s)", lhs and rhs refer to the converted operand(s).
1) The result of built-in multiplication is the product of the operands.
If both operands have a floating-point type, and the type supports IEEE floating-point arithmetic (see
std::numeric_limits::is_iec559
):
Multiplication of a NaN by any number gives NaN.
Multiplication of infinity by zero gives NaN and
is raised.
2) The result of built-in division is lhs divided by rhs. If rhs is zero, the behavior is undefined.
If both operands have an integral type, the result is the algebraic quotient (performs integer division): the quotient is truncated towards zero (fractional part is discarded).
If both operands have a floating-point type, and the type supports IEEE floating-point arithmetic (see
std::numeric_limits::is_iec559
):
If one operand is NaN, the result is NaN.
Dividing a non-zero number by ±0.0 gives the correctly-signed infinity and
is raised.
Dividing 0.0 by 0.0 gives NaN and
is raised.
3) The result of built-in remainder is the remainder of the integer division of lhs by rhs. If rhs is zero, the behavior is undefined.
If a / b is representable in the result type, (a / b) * b + a % b == a.
If a / b is not representable in the result type, the behavior of both a / b and a % b is undefined (that means INT_MIN % -1 is undefined on two's complement systems).
Note: Until
was resolved (
), 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 function
provided well-defined behavior in that case.
Note: for floating-point remainder, see
and
.
Overloads
In
overload resolution against user-defined operators
, for every pair of promoted arithmetic types LA and RA and for every pair of promoted integral types LI and RI the following function signatures participate in overload resolution:
LRA operator*(LA, RA)LRA operator/(LA, RA)LRI operator%(LI, RI)where LRx is the result of
on Lx and Rx.
Run this code
#include <iostream> int main() { char c = 2; unsigned int 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'; }Output:
2 * (-10), where 2 is a char = -20 2 * (-10), where 2 is unsigned = 4294967276 -10 / 2.12 = -4.71698 -10 / 21 = 0 -10 % 21 = -10Bitwise logic operators
The bitwise logic operator expressions have the form
~rhs(1) lhs&rhs(2) lhs|rhs(3) lhs^rhs(4) 1) Bitwise NOT.
2) Bitwise AND.
3) Bitwise OR.
4) Bitwise XOR.
The bitwise NOT operator has higher
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 a
or
specifier(since C++11): it can either be operator~ or start a
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 lower
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) * c d / 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) & l m | n ^ o // equivalent to m | (n ^ o)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 on rhs. For other built-in bitwise logic operators, both operands must have integral or unscoped enumeration type, and
are performed on both operands.
In the remaining description in this section, "operand(s)", lhs and rhs refer to the converted or promoted operand(s).
1) Given the operand as x and the result of the built-in bitwise NOT operation as r. For each coefficient x_i of the base-2 representation of x, the corresponding coefficient r_i of the base-2 representation of r is 1 if x_i is 0, and 0 otherwise.
In other words, the result is the one’s complement of the operand (where operand and result are considered as unsigned).
The type of the result r is the type of the operand x.
2-4) Given the operands as x and y respectively and the result of the built-in binary bitwise logic operations as r. For each pair of coefficients x_i and y_i of the base-2 representations of x and y respectively, the corresponding coefficient r_i of the base-2 representation of r is
2)1 if both x_i and y_i are 1, and 0 otherwise.
3)1 if at least one of x_i and y_i is 1, and 0 otherwise.
4)1 if either (but not both) of x_i and y_i is 1, and 0 otherwise.
The type of the result r is the type of the operands x and y.
Overloads
In
overload resolution against user-defined operators
, for every pair of promoted integral types L and R the following function signatures participate in overload resolution:
R operator~(R)LR operator&(L, R)LR operator^(L, R)LR operator|(L, R)where LR is the result of
on L and R.
Run this code
#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'; }Output:
Mask: 0xf0 0000000011110000 Value: 0x12345678 00010010001101000101011001111000 Setting bits: 0x123456f8 00010010001101000101011011111000 Clearing bits: 0x12345608 00010010001101000101011000001000 Selecting bits: 0x70 00000000000000000000000001110000 XOR-ing bits: 0x12345688 00010010001101000101011010001000 Inverting bits: 0xedcba987 11101101110010111010100110000111Bitwise shift operators
The bitwise shift operator expressions have the form
lhs<<rhs(1) lhs>>rhs(2) 1) Bitwise left-shift.
2) Bitwise right-shift.
Bitwise shift operators have higher
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) * c d << e & f; // equivalent to (d << e) & f, NOT d << (e & f) g << h >> i; // equivalent to (g << h) >> i, NOT g << (h >> i)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 and rhs refer to the converted or promoted operand(s).
If the value of rhs is negative or is not less than the number of bits in lhs, the behavior is undefined.
For unsigned a, the value of a << b is the value of a * 2b
, reduced modulo 2N
where N is the number of bits in the return type (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded).
For signed and non-negative a, if a * 2b
is representable in the unsigned version of the return type, then that value,
to signed, is the value of a << b (this makes it legal to create
as 1 << 31); otherwise the behavior is undefined.
For negative a, the behavior of a << b is undefined.
For unsigned a and for signed and non-negative a, the value of a >> b is the integer part of a/2b
.
For negative a, the value of a >> b is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative).
(until C++20)The value of a << b is the unique value congruent to a * 2b
modulo 2N
where N is the number of bits in the return type (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded).
The value of a >> b is a/2b
, rounded towards negative infinity (in other words, right shift on signed a is arithmetic right shift).
(since C++20)The type of the result is that of lhs.
Overloads
In
overload resolution against user-defined operators
, for every pair of promoted integral types L and R, the following function signatures participate in overload resolution:
L operator<<(L, R)L operator>>(L, R)Run this code
#include <iostream> enum { ONE = 1, TWO = 2 }; int main() { std::cout << std::hex << std::showbase; char c = 0x10; unsigned long long 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 int long long ll = -1000; std::cout << std::dec << "-1000 >> 1 = " << (ll >> ONE) << '\n'; }Output:
0x123 << 1 = 0x246 0x123 << 63 = 0x8000000000000000 0x10 << 10 = 0x4000 -1000 >> 1 = -500Standard library
Arithmetic operators are overloaded for many standard library types.
Unary arithmetic operators
Additive operators
(C++11)
performs add and subtract operations involving a time point
(function template)
operator+operator-operator*operator/operator%
(C++11)
implements arithmetic operations with durations as arguments
(function template)
(C++20)
adds or subtracts a year_month_day and some number of years or months
(function)
concatenates two strings, a string and a char, or a string and
(function template)
advances or decrements the iterator
(public member function of std::reverse_iterator<Iter>)
advances or decrements the iterator
(public member function of std::move_iterator<Iter>)
operator+operator-operator*operator/
performs complex number arithmetic on two complex values or a complex and a scalar
(function template)
applies binary operators to each element of two valarrays, or a valarray and a value
(function template)
Multiplicative operators
Bitwise logic operators
Bitwise shift operators
applies binary operators to each element of two valarrays, or a valarray and a value
(function template)performs binary shift left and shift right
(public member function of std::bitset<N>)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 as stream insertion and stream extraction operators:
extracts formatted data
(public member function of std::basic_istream<CharT,Traits>)
operator>>(std::basic_istream)
extracts characters and character arrays
(function template)
inserts formatted data
(public member function of std::basic_ostream<CharT,Traits>)
operator<<(std::basic_ostream)
inserts character data or insert into rvalue stream
(function template)
serializes and deserializes a complex number
(function template)
performs stream input and output of bitsets
(function template)
performs stream input and output on strings
(function template)
(C++11)
performs stream input and output on pseudo-random number engine
(function template)
(C++11)
performs stream input and output on pseudo-random number distribution
(function template)
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR Applied to Behavior as published Correct behavior
C++98 the algebraic quotient of integer division was
rounded in implementation-defined direction the algebraic quotient of integer
division is truncated towards zero
(fractional part is discarded)
C++98 the result of a / b was unspecified if
it is not representable in the result type the behavior of both a / b and
a % b is undefined in this case
C++98 the behavior of shifting the leftmost 1 bit of a
positive signed value into the sign bit was undefined made well-defined
C++98 a pointer to a base class subobject of an array
element could be used in pointer arithmetic the behavior is
undefined in this case
C++98 only unsigned integers which declared unsigned
should obey the laws of arithmetic modulo 2n
applies to all unsigned integers
C++98 arithmetic operators allow their operands to be lvalues some operands must be rvalues
C++98 the resolution of
made the behaviors
of pointer arithmetic involving pointers to array element
undefined if the pointed-to type and the array element
type have different cv-qualifications in non-top levels made well-defined
C++98 it was unclear whether the rule resolving the
ambiguity of ~ applies to cases such as ~X(0)the rule applies to such cases
C++98 a pointer to non-array object was only treated as a
pointer to the first element of an array with size 1
in pointer arithmetic if the pointer is obtained by &applies to all pointers
to non-array objects
C++98 the result of built-in operator~ was simply
'one's complement' without proper definition the result is phrased in terms
of the base-2 representation
C++20 the rounding direction of arithmetic right shift was unclear made clear
C++98 a pointer past the end of an object could
not be added or subtracted with an integer it can See also
Common operators
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 || ba == b a != b a < b a > b a <= b a >= b a <=> ba[...] *a &a a->b a.b a->*b a.*bfunction calla(...)
commaa, b
conditionala ? b : c
Special operators
converts one type to another related type
converts within inheritance hierarchies
adds or removes
-qualifiers
converts type to unrelated type
converts one type to another by a mix of static_cast, const_cast, and reinterpret_cast
creates objects with dynamic storage duration
destructs objects previously created by the new expression and releases obtained memory area
queries the size of a type
queries the size of a
(since C++11)
queries the type information of a type
checks if an expression can throw an exception (since C++11)
queries alignment requirements of a type (since C++11)
produces a reflection value from a grammatical construct (since C++26)