名稱空間
變體
操作

算術運算子

來自 cppreference.com
< cpp‎ | 語言
 
C++
 
C++ 語言
 
表示式
通用
字面量
運算子
轉換
 

返回特定算術運算的結果。

運算子名稱 語法 原型示例（對於 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。

目錄

[編輯] 一般解釋

所有內建算術運算子都計算特定算術運算的結果並返回其結果。引數不會被修改。

[編輯] 轉換

如果傳遞給內建算術運算子的運算元是整型或無作用域列舉型別，則在任何其他操作之前（但在左值到右值轉換之後，如果適用），運算元將進行整型提升。如果運算元具有陣列或函式型別，則應用陣列到指標和函式到指標轉換。

對於二元運算子（除了移位），如果提升後的運算元具有不同的型別，則應用常用算術轉換。

[編輯] 溢位

無符號整數算術始終執行 模 2n
 運算，其中 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 的值是 2N
-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 * 2b
 的值，對 2N
 取模，其中 N 是返回型別中的位數（也就是說，執行按位左移，並丟棄超出目標型別的位）。

對於有符號且非負的 a，如果 a * 2b
 可在返回型別的無符號版本中表示，則該值轉換為有符號後，就是 a << b 的值（這使得將 INT_MIN 建立為 1 << 31 成為合法行為）；否則行為未定義。

對於負的 a，a << b 的行為未定義。

對於無符號 a 和有符號且非負的 a，a >> b 的值是 a/2b
 的整數部分。

對於負的 a，a >> b 的值是實現定義的（在大多數實現中，這會執行算術右移，使得結果保持負值）。

 (C++20 前)

a << b 的值是唯一一個與 a * 2b
 在模 2N
 下同餘的值，其中 N 是返回型別中的位數（也就是說，執行按位左移，並丟棄超出目標型別的位）。

a >> b 的值是 a/2b
，向負無窮大舍入（換句話說，有符號 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

[編輯] 標準庫

算術運算子已為許多標準庫型別過載。

[編輯] 一元算術運算子

 實現一元 + 和一元 -
(std::chrono::duration<Rep,Period> 的 public 成員函式) [編輯]
 對複數應用一元運算子
(函式模板) [編輯]
 對 valarray 的每個元素應用一元算術運算子
(std::valarray<T> 的 public 成員函式) [編輯]

[編輯] 加法運算子

(C++11)
 執行涉及時間點的加法和減法運算
(函式模板) [編輯]
(C++11)
 實現以持續時間為引數的算術運算
(函式模板) [編輯]
(C++20)
 新增或減去一個 year_month_day 和一些年或月
(函式) [編輯]
 連線兩個字串，一個字串和一個 char，或者一個字串和一個 string_view
(函式模板) [編輯]
 前進或後退迭代器
(std::reverse_iterator<Iter> 的 public 成員函式)
前進或後退迭代器
(std::move_iterator<Iter> 的 public 成員函式)
對兩個複數值或一個複數和一個標量執行復數算術
(函式模板) [編輯]
 對兩個 valarray 的每個元素，或一個 valarray 和一個值應用二元運算子
(函式模板) [編輯]

[編輯] 乘法運算子

(C++11)
 實現以持續時間為引數的算術運算
(函式模板) [編輯]
 對兩個複數值或一個複數和一個標量執行復數算術
(函式模板) [編輯]
 對兩個 valarray 的每個元素，或一個 valarray 和一個值應用二元運算子
(函式模板) [編輯]

[編輯] 按位邏輯運算子

 執行二進位制 AND、OR、XOR 和 NOT
(std::bitset<N> 的 public 成員函式) [編輯]
 對位集執行二進位制邏輯操作
(函式模板) [編輯]
 對 valarray 的每個元素應用一元算術運算子
(std::valarray<T> 的 public 成員函式)
對兩個 valarray 的每個元素，或一個 valarray 和一個值應用二元運算子
(函式模板)

[編輯] 按位移位運算子

 對兩個 valarray 的每個元素，或一個 valarray 和一個值應用二元運算子
(函式模板)
執行二進位制左移和右移
(std::bitset<N> 的 public 成員函式)

[編輯] 流插入/提取運算子

在整個標準庫中，按位移位運算子通常被過載，將 I/O 流（std::ios_base& 或其派生類之一）作為左運算元和返回型別。這些運算子被稱為 流插入 和 流提取 運算子。

 提取格式化資料
(std::basic_istream<CharT,Traits> 的 public 成員函式) [編輯]
 提取字元和字元陣列
(函式模板) [編輯]
 插入格式化資料
(std::basic_ostream<CharT,Traits> 的 public 成員函式) [編輯]
 插入字元資料或插入到右值流中
(函式模板) [編輯]
 序列化和反序列化複數
(函式模板) [編輯]
 執行位集的流輸入和輸出
(函式模板) [編輯]
 對字串執行流輸入和輸出
(函式模板) [編輯]
(C++11)
 對偽隨機數引擎執行流輸入和輸出
(函式模板) [編輯]
(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 文件 用於 算術運算子
取自 "https://cppreference.tw/mwiki/index.php?title=cpp/language/operator_arithmetic&oldid=172816"