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:

#include <iostream>

int main()
{
    char c = 0x6a;
    int n1 = 1;
    unsigned char n2 = 1;
    unsigned int 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: 4294967295
size of array: 3
size of pointer: 8

Additive operators

The additive operator expressions have the form

1) Binary plus (addition).

2) Binary minus (subtraction).

Binary + and - operators have higher precedence 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) * 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) - m

Built-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, 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 and rhs refer to the converted or promoted operand(s).

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 FE_INVALID is raised.
• Infinity plus the negative infinity is NaN, and FE_INVALID 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 null pointer value 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 std::ptrdiff_t.

• If P and Q both evaluate to null pointer values, 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 std::ptrdiff_t, 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 LegacyRandomAccessIterator 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 similar, 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 int

Overloads

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:

where LR is the result of usual arithmetic conversions on L and R.

#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';
}

 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: 3

Multiplicative operators

The multiplicative operator expressions have the form

1) Multiplication.

2) Division.

3) Remainder.

Multiplicative operators have higher precedence 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) % m

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 and rhs refer to the converted operand(s).

1) The result of built-in multiplication is the product of the operands.

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).

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 CWG 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 function std::div provided well-defined behavior in that case.

Note: for floating-point remainder, see std::remainder and std::fmod.

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:

where LRx is the result of usual arithmetic conversions on Lx and Rx.

#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';
}

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  = -10

Bitwise logic operators

The bitwise logic operator expressions have the form

1) Bitwise NOT.

2) Bitwise AND.

3) Bitwise OR.

4) Bitwise XOR.

The bitwise NOT operator has higher precedence 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 type name or decltype specifier(since C++11): it can either be operator~ or start a destructor 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 precedence 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 usual arithmetic conversions 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).

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:

where LR is the result of usual arithmetic conversions on L and R.

#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                                 0000000011110000
Value: 0x12345678          00010010001101000101011001111000
Setting bits: 0x123456f8   00010010001101000101011011111000
Clearing bits: 0x12345608  00010010001101000101011000001000
Selecting bits: 0x70       00000000000000000000000001110000
XOR-ing bits: 0x12345688   00010010001101000101011010001000
Inverting bits: 0xedcba987 11101101110010111010100110000111

Bitwise shift operators

The bitwise shift operator expressions have the form

1) Bitwise left-shift.

2) Bitwise right-shift.

Bitwise shift operators have higher precedence 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.

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:

#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';
}

0x123 << 1 = 0x246
0x123 << 63 = 0x8000000000000000
0x10 << 10 = 0x4000
-1000 >> 1 = -500

Standard library

Arithmetic operators are overloaded for many standard library types.

Unary arithmetic operators

Additive operators

Multiplicative operators

Bitwise logic operators

Bitwise shift 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 as stream insertion and stream extraction operators:

Defect reports

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

See also

Operator precedence

Operator overloading