算术运算符

返回特定算术运算的结果。

运算符名称	语法	原型示例（对于 class T）
运算符名称	语法	类定义内部	类定义外部
一元加	+a	T T::operator+() const;	T operator+(const T& a);
一元减	-a	T T::operator-() const;	T operator-(const T& a);
加法	a + b	T T::operator+(const T2& b) const;	T operator+(const T& a, const T2& b);
减法	a - b	T T::operator-(const T2& b) const;	T operator-(const T& a, const T2& b);
乘法	a * b	T T::operator*(const T2& b) const;	T operator*(const T& a, const T2& b);
除法	a / b	T T::operator/(const T2& b) const;	T operator/(const T& a, const T2& b);
取余	a % b	T T::operator%(const T2& b) const;	T operator%(const T& a, const T2& b);
按位非	~a	T T::operator~() const;	T operator~(const T& a);
按位与	a & b	T T::operator&(const T2& b) const;	T operator&(const T& a, const T2& b);
按位或	a \| b	T T::operator\|(const T2& b) const;	T operator\|(const T& a, const T2& b);
按位异或	a ^ b	T T::operator^(const T2& b) const;	T operator^(const T& a, const T2& b);
按位左移	a << b	T T::operator<<(const T2& b) const;	T operator<<(const T& a, const T2& b);
按位右移	a >> b	T T::operator>>(const T2& b) const;	T operator>>(const T& a, const T2& b);
注意此表中的所有运算符都是可重载的。所有内置运算符都返回值，并且大多数用户定义重载也返回值，以便用户定义的运算符可以像内置运算符一样使用。然而，在用户定义的运算符重载中，任何类型都可以用作返回类型（包括 void）。特别是，operator<< 和 operator>> 的流插入和流提取重载返回 `T&`。 `T2` 可以是任何类型，包括 `T`。

[编辑] 一般解释

所有内置算术运算符都计算特定算术运算的结果并返回其结果。参数不会被修改。

[编辑] 转换

如果传递给内置算术运算符的操作数是整型或无作用域枚举类型，则在任何其他操作之前（但在左值到右值转换之后，如果适用），操作数将进行整型提升。如果操作数具有数组或函数类型，则应用数组到指针和函数到指针转换。

对于二元运算符（除了移位），如果提升后的操作数具有不同的类型，则应用常用算术转换。

[编辑] 溢出

无符号整数算术始终执行 $模 2 n$ 运算，其中 n 是该特定整数中的位数。例如，对于 unsigned int，将 UINT_MAX 加一会得到 0，从 0 减一会得到 UINT_MAX。

当有符号整数算术运算溢出（结果不适合结果类型）时，行为是未定义的，——这种操作的可能表现包括

它根据表示规则（通常是二补数）进行环绕，
它会捕获 — 在某些平台或由于编译器选项（例如 GCC 和 Clang 中的 -ftrapv），
它会饱和到最小值或最大值（在许多 DSP 上），
它被编译器完全优化掉。

[编辑] 浮点环境

如果支持 #pragma STDC FENV_ACCESS 并设置为 ON，所有浮点算术运算符都遵循当前的浮点舍入方向，并按照math_errhandling中指定的方式报告浮点算术错误，除非是静态初始化器的一部分（在这种情况下，不会引发浮点异常，并且舍入模式为最近）。

[编辑] 浮点收缩

除非支持 #pragma STDC FP_CONTRACT 并设置为 OFF，所有浮点算术可以执行，就好像中间结果具有无限范围和精度一样，也就是说，允许省略舍入错误和浮点异常的优化。例如，C++ 允许使用单个融合乘加 CPU 指令实现 (x * y) + z，或者将 a = x * x * x * x; 优化为 tmp = x * x; a = tmp * tmp。

与收缩无关，浮点算术的中间结果可能具有与其类型指示不同的范围和精度，参见 FLT_EVAL_METHOD。

形式上，C++ 标准不保证浮点运算的准确性。

[编辑] 一元算术运算符

一元算术运算符表达式的形式为


`+` 表达式	(1)

`-` 表达式	(2)

1) 一元加（提升）。

2) 一元减（取反）。

一元 + 和 - 运算符的优先级高于所有二元算术运算符，因此表达式不能包含顶级二元算术运算符。这些运算符从右向左结合。

+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

[编辑] 内置一元算术运算符

1) 对于内置一元加运算符，expression 必须是算术类型、无作用域枚举类型或指针类型的 prvalue。如果expression 具有整型或无作用域枚举类型，则对其执行整型提升。结果的类型是 expression 的（可能已提升的）类型。

内置提升的结果是 expression 的值。如果操作数是已提升的整型类型的 prvalue 或指针类型，则内置一元操作是空操作。否则，操作数的类型或值类别通过整型提升或左值到右值、数组到指针、函数到指针或用户定义转换而改变。例如，在 unary plus 表达式中，char 被转换为 int ，并且非泛型无捕获的lambda 表达式被转换为函数指针(C++11 起)。

2) 对于内置一元减运算符，expression 必须是算术类型或无作用域枚举类型的 prvalue。对 expression 执行整型提升。结果的类型是 expression 的提升类型的类型。

内置取反的结果是提升后的 expression 的负值。对于无符号 a，-a 的值是

2 N -a

，其中 N 是提升后的位数。

换句话说，结果是操作数的补码（操作数和结果都被视为无符号）。

[编辑] 重载

在针对用户定义运算符的重载决议中，对于每个 cv-非限定的提升算术类型 A 和每个类型 T，以下函数签名参与重载决议：

A operator+(A)
T* operator+(T*)
A operator-(A)

运行此代码

#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

[编辑] 加法运算符

加法运算符表达式的形式为


lhs `+` rhs	(1)

lhs `-` rhs	(2)

1) 二元加（加法）。

2) 二元减（减法）。

二元 + 和 - 运算符的优先级高于所有其他二元算术运算符，除了 *、/ 和 %。这些运算符从左到右结合。

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

[编辑] 内置加法运算符

对于内置二元加法和二元减法运算符，lhs 和 rhs 都必须是 prvalue，并且必须满足以下条件之一

两个操作数都具有算术或无作用域枚举类型。在这种情况下，对两个操作数执行常用算术转换。
恰好一个操作数具有整型或无作用域枚举类型。在这种情况下，对该操作数应用整型提升。

在本节的其余描述中，“操作数”、“lhs”和“rhs”指转换或提升后的操作数。

1) 对于内置加法，必须满足以下条件之一

两个操作数都具有算术类型。在这种情况下，结果是操作数之和。
一个操作数是指向完全定义的对象类型的指针，另一个操作数具有整型。在这种情况下，将整型值添加到指针（参见指针算术）。

2) 对于内置减法，必须满足以下条件之一

两个操作数都具有算术类型。在这种情况下，结果是 lhs 减去 rhs 的差。
lhs 是指向完全定义的对象类型的指针，并且 rhs 具有整型。在这种情况下，从指针中减去整型值（参见指针算术）。
两个操作数都是指向相同完全定义对象类型的 cv 限定或 cv 非限定版本的指针。在这种情况下，lhs 减去 rhs（参见指针算术）。

如果两个操作数都具有浮点类型，并且该类型支持 IEEE 浮点算术（参见 std::numeric_limits::is_iec559）

如果一个操作数是 NaN，结果是 NaN。
无穷大减无穷大是 NaN，并引发 FE_INVALID。
无穷大加负无穷大是 NaN，并引发 FE_INVALID。

[编辑] 指针算术

当具有整型类型的表达式 J 与指针类型表达式 P 相加或相减时，结果具有 P 的类型。

如果 P 求值为空指针值且 J 求值为 0，则结果为空指针值。
否则，如果 P 指向具有 n 个元素的数组对象 x 的第 i 个元素，给定 J 的值为 j，P 按如下方式相加或相减

表达式 P + J 和 J + P

如果 i + j 在 [0, n) 范围内，则指向 x 的第 i+j 个元素，并且
如果 i + j 是 n，则是指向 x 的最后一个元素之后的指针。

表达式 P - J

如果 i - j 在 [0, n) 范围内，则指向 x 的第 i-j 个元素，并且
如果 i - j 是 n，则是指向 x 的最后一个元素之后的指针。

其他 j 值会导致未定义行为。

否则，如果 P 指向一个完整对象、基类子对象或成员子对象 y，给定 J 的值为 j，P 按如下方式相加或相减

表达式 P + J 和 J + P

如果 j 是 0，则指向 y，并且
如果 j 是 1，则是指向 y 之后的指针。

表达式 P - J

如果 j 是 0，则指向 y，并且
如果 j 是 -1，则是指向 y 之后的指针。

其他 j 值会导致未定义行为。

否则，如果 P 是指向对象 z 之后的一个指针，给定 J 的值为 j

如果 z 是一个具有 n 个元素的数组对象，P 按如下方式相加或相减

表达式 P + J 和 J + P

如果 n + j 在 [0, n) 范围内，则指向 z 的第 n+j 个元素，并且
如果 j 是 0，则是指向 z 的最后一个元素之后的指针。

表达式 P - J

如果 n - j 在 [0, n) 范围内，则指向 z 的第 n-j 个元素，并且
如果 j 是 0，则是指向 z 的最后一个元素之后的指针。

其他 j 值会导致未定义行为。

否则，P 按如下方式相加或相减

表达式 P + J 和 J + P

如果 j 是 -1，则指向 z，并且
如果 j 是 0，则是指向 z 之后的指针。

表达式 P - J

如果 j 是 1，则指向 z，并且
如果 j 是 0，则是指向 z 之后的指针。

其他 j 值会导致未定义行为。

否则，行为未定义。

当两个指针表达式 P 和 Q 相减时，结果的类型是 std::ptrdiff_t。

如果 P 和 Q 都求值为空指针值，则结果是 0。
否则，如果 P 和 Q 分别指向同一数组对象 x 的第 i 个和第 j 个数组元素，则表达式 P - Q 的值是 i − j。

如果 i − j 不能由 std::ptrdiff_t 表示，则行为未定义。

否则，如果 P 和 Q 指向同一个完整对象、基类子对象或成员子对象，则结果是 0。
否则，行为未定义。

这些指针算术运算符允许指针满足LegacyRandomAccessIterator要求。

对于加法和减法，如果 P 或 Q 的类型是“指向（可能 cv 限定的）T 的指针”，其中 T 和数组元素类型不相似，则行为未定义。

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

[编辑] 重载

在针对用户定义运算符的重载决议中，对于每对提升算术类型 L 和 R 以及每个对象类型 T，以下函数签名参与重载决议

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)

其中 LR 是对 L 和 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

[编辑] 乘法运算符

乘法运算符表达式的形式为


lhs `*` rhs	(1)

lhs `/` rhs	(2)

lhs `%` rhs	(3)

1) 乘法。

2) 除法。

3) 取余。

乘法运算符的优先级高于所有其他二元算术运算符。这些运算符从左到右结合。

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

[编辑] 内置乘法运算符

对于内置乘法和除法运算符，两个操作数都必须具有算术或无作用域枚举类型。对于内置取余运算符，两个操作数都必须具有整型或无作用域枚举类型。对两个操作数执行常用算术转换。

在本节的其余描述中，“操作数”、“lhs”和“rhs”指转换后的操作数。

1) 内置乘法的结果是操作数之积。

如果两个操作数都具有浮点类型，并且该类型支持 IEEE 浮点算术（参见 std::numeric_limits::is_iec559）

NaN 与任何数相乘都得到 NaN。
无穷大与零相乘得到 NaN，并引发 FE_INVALID。

2) 内置除法的结果是 lhs 除以 rhs。如果 rhs 为零，则行为未定义。

如果两个操作数都具有整型类型，则结果是代数商（执行整数除法）：商截断为零（小数部分被丢弃）。

如果两个操作数都具有浮点类型，并且该类型支持 IEEE 浮点算术（参见 std::numeric_limits::is_iec559）

如果一个操作数是 NaN，结果是 NaN。
非零数除以 ±0.0 得到正确符号的无穷大，并引发 FE_DIVBYZERO。
0.0 除以 0.0 得到 NaN，并引发 FE_INVALID。

3) 内置取余的结果是 lhs 除以 rhs 的整数除法的余数。如果 rhs 为零，则行为未定义。

如果 a / b 可在结果类型中表示，则 (a / b) * b + a % b == a。

如果 a / b 不可在结果类型中表示，则 a / b 和 a % b 的行为都未定义（这意味着在二补数系统上 INT_MIN % -1 未定义）。

注意：直到CWG 问题 614 得到解决（N2757），如果二元运算符 % 的一个或两个操作数是负数，余数的符号是实现定义的，因为它取决于整数除法的舍入方向。函数 std::div 在这种情况下提供了明确定义的行为。

注意：对于浮点余数，请参阅 std::remainder 和 std::fmod。

[编辑] 重载

在针对用户定义运算符的重载决议中，对于每对提升算术类型 LA 和 RA 以及每对提升整型类型 LI 和 RI，以下函数签名参与重载决议

LRA operator*(LA, RA)
LRA operator/(LA, RA)
LRI operator%(LI, RI)

其中 LRx 是对 Lx 和 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

[编辑] 按位逻辑运算符

按位逻辑运算符表达式的形式为


`~` rhs	(1)

lhs `&` rhs	(2)

lhs `\|` rhs	(3)

lhs `^` rhs	(4)

1) 按位非。

2) 按位与。

3) 按位或。

4) 按位异或。

按位非运算符的优先级高于所有二元算术运算符。它从右向左结合。

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

当 ~ 后跟类型名称或decltype 说明符(C++11 起)时，语法存在歧义：它可以是 operator~，也可以是析构函数标识符的开头。通过将 ~ 视为 operator~ 来解决此歧义。~ 只能在形成 operator~ 在语法上无效的位置开始析构函数标识符。

所有其他按位逻辑运算符的优先级低于所有其他二元算术运算符。按位与的优先级高于按位异或，按位异或的优先级高于按位或。它们从左向右结合。

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)

[编辑] 内置按位逻辑运算符

对于内置按位非运算符，rhs 必须是整型或无作用域枚举类型的 prvalue，并且对 rhs 执行整型提升。对于其他内置按位逻辑运算符，两个操作数都必须具有整型或无作用域枚举类型，并且对两个操作数执行常用算术转换。

在本节的其余描述中，“操作数”、“lhs”和“rhs”指转换或提升后的操作数。

1) 给定操作数为 x，内置按位非操作的结果为 r。对于 x 的二进制表示的每个系数 x_i，r 的二进制表示的相应系数 r_i 为 1，如果 x_i 为 0，否则为 0。

换句话说，结果是操作数的反码（操作数和结果都被视为无符号）。

结果 r 的类型是操作数 x 的类型。

2-4) 给定操作数分别为 x 和 y，内置二元按位逻辑操作的结果为 r。对于 x 和 y 的二进制表示的每对系数 x_i 和 y_i，r 的二进制表示的相应系数 r_i 为

2) 如果 x_i 和 y_i 都是 1，则为 1，否则为 0。

3) 如果 x_i 和 y_i 中至少有一个是 1，则为 1，否则为 0。

4) 如果 x_i 和 y_i 中任意一个（但不同时）是 1，则为 1，否则为 0。

结果 r 的类型是操作数 x 和 y 的类型。

[编辑] 重载

在针对用户定义运算符的重载决议中，对于每对提升整型类型 L 和 R，以下函数签名参与重载决议

R operator~(R)
LR operator&(L, R)
LR operator^(L, R)
LR operator\|(L, R)

其中 LR 是对 L 和 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

[编辑] 按位移位运算符

按位移位运算符表达式的形式为


lhs `<<` rhs	(1)

lhs `>>` rhs	(2)

1) 按位左移。

2) 按位右移。

按位移位运算符的优先级高于按位逻辑运算符，但低于加法和乘法运算符。这些运算符从左到右结合。

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)

[编辑] 内置按位移位运算符

对于内置按位移位运算符，两个操作数都必须是整型或无作用域枚举类型的 prvalue。对两个操作数执行整型提升。

在本节的其余描述中，“操作数”、“a”、“b”、“lhs”和“rhs”指转换或提升后的操作数。

如果 rhs 的值是负数或不小于 lhs 中的位数，则行为未定义。

对于无符号 a，a << b 的值是 $a * 2 b$ 的值，对 $2 N$ 取模，其中 N 是返回类型中的位数（也就是说，执行按位左移，并丢弃超出目标类型的位）。

对于有符号且非负的 a，如果 $a * 2 b$ 可在返回类型的无符号版本中表示，则该值转换为有符号后，就是 a << b 的值（这使得将 INT_MIN 创建为 1 << 31 成为合法行为）；否则行为未定义。

对于负的 a，a << b 的行为未定义。

对于无符号 a 和有符号且非负的 a，a >> b 的值是 $a/2 b$ 的整数部分。

对于负的 a，a >> b 的值是实现定义的（在大多数实现中，这会执行算术右移，使得结果保持负值）。

(C++20 前)

a << b 的值是唯一一个与 $a * 2 b$ 在模 $2 N$ 下同余的值，其中 N 是返回类型中的位数（也就是说，执行按位左移，并丢弃超出目标类型的位）。

a >> b 的值是 $a/2 b$ ，向负无穷大舍入（换句话说，有符号 a 的右移是算术右移）。

(C++20 起)

结果的类型是 lhs 的类型。

[编辑] 重载

在针对用户定义运算符的重载决议中，对于每对提升整型类型 L 和 R，以下函数签名参与重载决议

L operator<<(L, R)
L operator>>(L, R)

运行此代码

#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

[编辑] 标准库

算术运算符已为许多标准库类型重载。

[编辑] 一元算术运算符

operator+operator-	实现一元 + 和一元 - (`std::chrono::duration<Rep,Period>` 的 public 成员函数) [编辑]
operator+operator-	对复数应用一元运算符 (函数模板) [编辑]
operator+operator-operator~operator!	对 valarray 的每个元素应用一元算术运算符 (`std::valarray<T>` 的 public 成员函数) [编辑]

[编辑] 加法运算符

operator+operator- (C++11)	执行涉及时间点的加法和减法运算 (函数模板) [编辑]
operator+operator-operator*operator/operator% (C++11)	实现以持续时间为参数的算术运算 (函数模板) [编辑]
operator+operator- (C++20)	添加或减去一个 `year_month_day` 和一些年或月 (函数) [编辑]
operator+	连接两个字符串，一个字符串和一个 char，或者一个字符串和一个 string_view (函数模板) [编辑]
operator+operator-	前进或后退迭代器 (`std::reverse_iterator<Iter>` 的 public 成员函数)
operator+operator-	前进或后退迭代器 (`std::move_iterator<Iter>` 的 public 成员函数)
operator+operator-operator*operator/	对两个复数值或一个复数和一个标量执行复数算术 (函数模板) [编辑]
operator+operator-operator*operator/operator%operator&operator\|operator^operator<<operator>>operator&&operator\|\|	对两个 valarray 的每个元素，或一个 valarray 和一个值应用二元运算符 (函数模板) [编辑]

[编辑] 乘法运算符

operator+operator-operator*operator/operator% (C++11)	实现以持续时间为参数的算术运算 (函数模板) [编辑]
operator+operator-operator*operator/	对两个复数值或一个复数和一个标量执行复数算术 (函数模板) [编辑]
operator+operator-operator*operator/operator%operator&operator\|operator^operator<<operator>>operator&&operator\|\|	对两个 valarray 的每个元素，或一个 valarray 和一个值应用二元运算符 (函数模板) [编辑]

[编辑] 按位逻辑运算符

operator&=operator\|=operator^=operator~	执行二进制 AND、OR、XOR 和 NOT (`std::bitset<N>` 的 public 成员函数) [编辑]
operator&operator\|operator^	对位集执行二进制逻辑操作 (函数模板) [编辑]
operator~	对 valarray 的每个元素应用一元算术运算符 (`std::valarray<T>` 的 public 成员函数)
operator^operator&operator\|	对两个 valarray 的每个元素，或一个 valarray 和一个值应用二元运算符 (函数模板)

[编辑] 按位移位运算符

operator<<operator>>	对两个 valarray 的每个元素，或一个 valarray 和一个值应用二元运算符 (函数模板)
operator<<operator>>	执行二进制左移和右移 (`std::bitset<N>` 的 public 成员函数)

[编辑] 流插入/提取运算符

在整个标准库中，按位移位运算符通常被重载，将 I/O 流（std::ios_base& 或其派生类之一）作为左操作数和返回类型。这些运算符被称为 流插入 和 流提取 运算符。

operator>>	提取格式化数据 (`std::basic_istream<CharT,Traits>` 的 public 成员函数) [编辑]
operator>>(std::basic_istream)	提取字符和字符数组 (函数模板) [编辑]
operator<<	插入格式化数据 (`std::basic_ostream<CharT,Traits>` 的 public 成员函数) [编辑]
operator<<(std::basic_ostream)	插入字符数据或插入到右值流中 (函数模板) [编辑]
operator<<operator>>	序列化和反序列化复数 (函数模板) [编辑]
operator<<operator>>	执行位集的流输入和输出 (函数模板) [编辑]
operator<<operator>>	对字符串执行流输入和输出 (函数模板) [编辑]
operator<<operator>> (C++11)	对伪随机数引擎执行流输入和输出 (函数模板) [编辑]
operator<<operator>> (C++11)	对伪随机数分布执行流输入和输出 (函数模板) [编辑]

[编辑] 缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	发布时的行为	正确的行为
CWG 614	C++98	整数除法的代数商按实现定义的方向进行舍入	整数的代数商除法向零截断（小数部分被丢弃）
CWG 1450	C++98	如果 a / b 的结果无法用结果类型表示，则结果未指定	在这种情况下，a / b 和 a % b 的行为是未定义的
CWG 1457	C++98	将正有符号值的最左侧 `1` 位移入符号位的行为是未定义的是未定义的	已明确定义
CWG 1504	C++98	指向数组元素的基类子对象的指针可在指针算术中使用	在这种情况下，行为是未定义的
CWG 1515	C++98	只有声明为 unsigned 的无符号整数才应遵循算术模 2n 的法则	适用于所有无符号整数
CWG 1642	C++98	算术运算符允许其操作数为左值	某些操作数必须是右值
CWG 1865	C++98	CWG issue 1504 的解决方案使涉及指向数组元素的指针的指针算术行为未定义，如果指向的类型和数组元素类型在非顶层具有不同的 cv 限定	已明确定义
CWG 1971	C++98	不清楚解决 ~ 的歧义的规则是否适用于诸如 ~X(0) 的情况	该规则适用于此类情况
CWG 2419	C++98	指向非数组对象的指针仅在指针算术中被视为指向大小为 1 的数组的第一个元素的指针如果该指针是通过 & 获得的	适用于所有非数组对象的指针
CWG 2626	C++98	内置 `operator~` 的结果只是 “一补码”而没有适当的定义	结果用二进制表示来表达
CWG 2724	C++20	算术右移的舍入方向不明确	已明确
CWG 2853	C++98	一个超出对象末尾的指针不能与整数相加或相减	它可以

[编辑] 参见

运算符优先级

运算符重载

常见运算符
赋值	递增递减	算术	逻辑	比较	成员访问	其他
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	函数调用 a(...)
						逗号 a, b
						条件 a ? b : c
特殊运算符
`static_cast` 将一种类型转换为另一种相关类型 `dynamic_cast` 在继承层次结构内进行转换 `const_cast` 添加或移除 cv-限定符 `reinterpret_cast` 将类型转换为不相关类型 C 风格转换通过 static_cast、const_cast 和 reinterpret_cast 的组合将一种类型转换为另一种类型 `new` 创建具有动态存储期的对象 `delete` 销毁先前由 new 表达式创建的对象并释放获得的内存区域 `sizeof` 查询类型的大小 `sizeof...` 查询包的大小 (C++11 起) `typeid` 查询类型的类型信息 `noexcept` 检查表达式是否可以抛出异常 (C++11 起) `alignof` 查询类型的对齐要求 (C++11 起)

C 文档用于算术运算符

编译器支持
自由（freestanding）与宿主（hosted）
语言
标准库
标准库头文件
具名要求
特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.cn

命名空间

变体

视图

操作

算术运算符

目录

[编辑] 一般解释

[编辑] 转换

[编辑] 溢出

[编辑] 浮点环境

[编辑] 浮点收缩

[编辑] 一元算术运算符

[编辑] 内置一元算术运算符

[编辑] 重载

[编辑] 加法运算符

[编辑] 内置加法运算符

[编辑] 指针算术

[编辑] 重载

[编辑] 乘法运算符

[编辑] 内置乘法运算符

[编辑] 重载

[编辑] 按位逻辑运算符

[编辑] 内置按位逻辑运算符

[编辑] 重载

[编辑] 按位移位运算符

[编辑] 内置按位移位运算符

[编辑] 重载

[编辑] 标准库

[编辑] 一元算术运算符

[编辑] 加法运算符

[编辑] 乘法运算符

[编辑] 按位逻辑运算符

[编辑] 按位移位运算符

[编辑] 流插入/提取运算符

[编辑] 缺陷报告

[编辑] 参见

导航

工具箱