Arithmetic operators

特定の算術演算の結果を返します。

概要説明

組み込みの算術演算子はすべて、特定の算術演算の結果を計算し、その結果を返します。引数は変更されません。

変換

組み込み算術演算子に渡されるオペランドが整数型またはスコープなし列挙型の場合、他のすべてのアクションの前（ただし該当する場合は左辺値から右辺値への変換の後）に、オペランドは 整数プロモーション を受けます。オペランドが配列型または関数型を持つ場合、 配列からポインタへの および 関数からポインタへの 変換が適用されます。

二項演算子（シフト演算子を除く）において、昇格後のオペランドの型が異なる場合、 通常の算術変換 が適用されます。

オーバーフロー

符号なし整数演算は常に 2 n
を法として実行されます。ここでnはその整数のビット数です。例: unsigned int の場合、 UINT_MAX に1を加算すると ​ 0 ​ となり、 ​ 0 ​ から1を減算すると UINT_MAX となります。

符号付き整数の算術演算がオーバーフローした場合（結果が結果の型に収まらない）、その動作は未定義です。— このような演算の可能性のある現れ方には以下が含まれます：

• それは表現の規則（一般的に 2の補数 ）に従ってラップアラウンドします、
• トラップする — 一部のプラットフォームまたはコンパイラオプションにより（例： -ftrapv in GCC and Clang）、
• 最小値または最大値に飽和します（多くのDSPで）、
• 完全に コンパイラによって最適化除去されます 。

浮動小数点環境

#pragma STDC FENV_ACCESS がサポートされており、かつ ON に設定されている場合、すべての浮動小数点算術演算子は現在の浮動小数点 丸め方向 に従い、 math_errhandling で指定されている通りに浮動小数点算術エラーを報告します。ただし、 静的初期化子 の一部である場合を除きます（その場合、浮動小数点例外は発生せず、丸めモードは最近接偶数丸めとなります）。

浮動小数点縮約

#pragma STDC FP_CONTRACT がサポートされておらず、かつ OFF に設定されていない限り、すべての浮動小数点演算は中間結果が無限の範囲と精度を持つかのように実行されてもよい。すなわち、丸め誤差や浮動小数点例外を省略する最適化が許可される。例えば、C++では ( x * y ) + z の実装を単一の融合積和演算CPU命令で行うことや、 a = x * x * x * x ; を tmp = x * x ; a = tmp * tmp として最適化することが許可されている。

契約とは無関係に、浮動小数点演算の中間結果は、その型で示される範囲と精度とは異なる範囲と精度を持つ場合があります。詳細は FLT_EVAL_METHOD を参照してください。

形式的には、C++標準は浮動小数点演算の精度について保証を行いません。

単項算術演算子

単項算術演算子式の形式は以下の通りです

単項演算子 + および - はすべての二項算術演算子より高い 優先順位 を持つため、 expression はトップレベルの二項算術演算子を含むことはできません。これらの演算子は右から左への結合性を持ちます：

+a - b; // (+a) - b と等価、+(a - b) ではない
-c + d; // (-c) + d と等価、-(c + d) ではない
+-e; // +(-e) と等価、単項演算子の + は「e」が組み込み型の場合には無効操作となる
     // なぜなら、あらゆる可能性のある昇格は否定演算中に既に実行されるため

組み込み単項算術演算子

オーバーロード

ユーザー定義演算子に対するオーバーロード解決 において、すべてのCV修飾子なし昇格算術型 A およびすべての型 T について、以下の関数シグネチャがオーバーロード解決に参加します：

#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

加算演算子

加算演算子の式は以下の形式を持ちます

二項演算子 + および - は、 * 、 / 、 % を除く他のすべての二項算術演算子よりも高い 優先順位 を持ちます。これらの演算子は左から右へ結合します：

a + b * c;  // a + (b * c) と等価、(a + b) * c ではない
d / e - f;  // (d / e) - f と等価、d / (e - f) ではない
g + h >> i; // (g + h) >> i と等価、g + (h >> i) ではない
j - k + l - m; // ((j - k) + l) - m と等価

組み込み加算演算子

組み込みの二項プラス演算子および二項マイナス演算子では、 lhs と rhs の両方がprvalueである必要があり、以下の条件のいずれかを満たさなければなりません：

• 両方のオペランドが算術型または非スコープ列挙型を持つ場合。 この場合、 通常の算術変換 が両方のオペランドに対して実行されます。
• 厳密に一方のオペランドのみが整数型または非スコープ列挙型を持つ場合。 この場合、そのオペランドに対して整数昇格が適用されます。

このセクションの残りの説明において、「オペランド」、 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 番目の要素を指す（ i + j が [ ​ 0 ​ , n ) の範囲内にある場合）
• x の最後の要素の次を指す（ i + j が n に等しい場合）

• 式 P - J

• i-j 番目の要素を指す（ i - j が [ ​ 0 ​ , n ) の範囲内にある場合）
• x の最後の要素の次を指す（ i - j が n に等しい場合）

• その他の 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 の値は未定義動作を引き起こします。

• それ以外の場合、動作は未定義です。

2つのポインタ式 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 が「(possibly cv-qualified) T へのポインタ」型を持ち、 T と配列要素型が similar でない場合、動作は未定義です：

int arr[5] = {1, 2, 3, 4, 5};
unsigned int *p = reinterpret_cast<unsigned int*>(arr + 1);
unsigned int k = *p; // OK、「k」の値は2
unsigned int *q = p + 1; // 未定義動作：「p」はunsigned intではなくintを指している

オーバーロード

ユーザー定義演算子に対するオーバーロード解決 において、昇格された算術型の各ペア L と R 、およびオブジェクト型 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

乗算演算子

乗算演算子の式は以下の形式を持ちます

乗法演算子は他のすべての二項算術演算子より高い 優先順位 を持ちます。これらの演算子は左から右へ結合します：

a + b * c;  // a + (b * c) と等価、(a + b) * c ではない
d / e - f;  // (d / e) - f と等価、d / (e - f) ではない
g % h >> i; // (g % h) >> i と等価、g % (h >> i) ではない
j * k / l % m; // ((j * k) / l) % m と等価

組み込み乗法演算子

組み込みの乗算演算子および除算演算子では、両方のオペランドが算術型または非スコープ列挙型でなければなりません。組み込みの剰余演算子では、両方のオペランドが整数型または非スコープ列挙型でなければなりません。 通常の算術変換 が両方のオペランドに対して実行されます。

このセクションの残りの説明において、「オペランド」、 lhs および rhs は変換後のオペランドを指します。

注記: CWG issue 614 が解決されるまで ( N2757 )、二項演算子 % の一方または両方のオペランドが負の場合、剰余の符号は処理系定義でした。これは整数除算の丸め方向に依存するためです。この場合、 std::div 関数は明確に定義された動作を提供します。

注: 浮動小数点剰余については、 std::remainder および std::fmod を参照してください。

オーバーロード

ユーザー定義演算子に対するオーバーロード解決 において、すべての昇格された算術型の組 LA と RA 、およびすべての昇格された整数型の組 LI と RI について、以下の関数シグネチャがオーバーロード解決に参加します：

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

ビット論理演算子

ビット単位論理演算子の式は以下の形式を持ちます

ビット単位NOT演算子はすべての二項算術演算子より 優先順位 が高くなります。右から左への結合性を持ちます：

~a - b; // (~a) - b と等価、~(a - b) ではない
~c * d; // (~c) * d と等価、~(c * d) ではない
~-e; // ~(-e) と等価

~ の後に 型名 または decltype 指定子 (C++11以降) が続く場合、文法上曖昧性が生じます。これは ~ がoperator~として解釈されるか、あるいは デストラクタ 識別子の開始となる可能性があるためです。この曖昧性は ~ をoperator~として扱うことで解決されます。 ~ がデストラクタ識別子として解釈されるのは、operator~の形成が構文的に不可能な場合のみです。

他のすべてのビット単位論理演算子は、他のすべての二項算術演算子より 優先順位 が低くなります。ビット単位ANDはビット単位XORより優先順位が高く、ビット単位XORはビット単位ORより優先順位が高くなります。これらは左から右へ結合します：

a & b * c;  // a & (b * c) と等価、(a & b) * c ではない
d / e ^ f;  // (d / e) ^ f と等価、d / (e ^ f) ではない
g << h | i; // (g << h) | i と等価、g << (h | i) ではない
j & k & l; // (j & k) & l と等価
m | n ^ o  // m | (n ^ o) と等価

組み込みビット論理演算子

組み込みのビット単位NOT演算子の場合、 rhs は整数型または非スコープ列挙型のprvalueでなければならず、 rhs に対して整数昇格が実行されます。他の組み込みビット単位論理演算子の場合、両オペランドは整数型または非スコープ列挙型でなければならず、両オペランドに対して 通常の算術変換 が実行されます。

このセクションの残りの説明において、「オペランド」、 lhs および rhs は、変換または昇格されたオペランドを指します。

オーバーロード

ユーザー定義演算子に対するオーバーロード解決 において、昇格された整数型の各ペア 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

ビットシフト演算子

ビット単位シフト演算子の式は以下の形式を持ちます

ビットシフト演算子はビット論理演算子より 優先順位 が高いですが、加算演算子と乗算演算子よりは低い優先順位を持ちます。これらの演算子は左から右への結合性を持ちます：

a >> b * c;  // a >> (b * c) と等価、(a >> b) * c ではない
d << e & f;  // (d << e) & f と等価、d << (e & f) ではない
g << h >> i; // (g << h) >> i と等価、g << (h >> i) ではない

組み込みビットシフト演算子

組み込みのビットシフト演算子では、両方のオペランドが整数型またはスコープなし列挙型のprvalueでなければなりません。両方のオペランドに対して整数昇格が実行されます。

このセクションの残りの説明において、「オペランド」、 a 、 b 、 lhs および rhs は、変換または昇格されたオペランドを指します。

rhs の値が負であるか、または lhs のビット数より小さくない場合、動作は未定義です。

結果の型は lhs の型となります。

オーバーロード

ユーザー定義演算子に対するオーバーロード解決 において、昇格された整数型の各ペア 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" // unsignedでのオーバーフロー
                 "0x10 << 10 = " << (c << 10) << '\n';   // charは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

標準ライブラリ

算術演算子は多くの標準ライブラリ型に対してオーバーロードされています。

単項算術演算子

加算演算子

乗算演算子

ビット論理演算子

ビット単位シフト演算子

ストリーム挿入/抽出演算子

標準ライブラリ全体において、ビット単位シフト演算子は一般的にI/Oストリーム（ std:: ios_base & またはその派生クラスのいずれか）を左オペランドおよび戻り値の型としてオーバーロードされます。このような演算子は ストリーム挿入 演算子および ストリーム抽出 演算子として知られています：

不具合報告

以下の動作変更の欠陥報告書は、以前に公開されたC++規格に対して遡及的に適用されました。

関連項目

演算子の優先順位

演算子のオーバーロード