Comparison operators

引数を比較します。

双方向比較

双方向比較演算子式の形式は以下の通りです

関係演算子

等価演算子

組み込み双方向比較演算子

組み込みの二項比較演算子では、 lvalue-to-rvalue conversions 、 array-to-pointer conversions (C++26まで) および function-to-pointer conversions が lhs と rhs に適用されます。

組み込みの双方向比較演算子の場合、結果は bool のprvalueとなります。

組み込み算術比較

変換された両オペランドが算術型または列挙型（スコープ付きまたはスコープなし）を持つ場合、 通常の算術変換 が両オペランドに対して実行されます。変換後の値が比較されます：

#include <iostream>
int main()
{
    static_assert(sizeof(unsigned char) < sizeof(int),
                  "Cannot compare signed and smaller unsigned properly");
    int a = -1;
    int b = 1;
    unsigned int c = 1;
    unsigned char d = 1;
    std::cout << std::boolalpha
              << "Comparing two signed values:\n"
                 " -1 == 1 ? " << (a == b) << "\n"
                 " -1 <  1 ? " << (a <  b) << "\n"
                 " -1 >  1 ? " << (a >  b) << "\n"
                 "Comparing signed and unsigned:\n"
                 // may issue different-signedness warning:
                 " -1 == 1 ? " << (a == c) << "\n"
                 // may issue different-signedness warning:
                 " -1 <  1 ? " << (a <  c) << "\n"
                 // may issue different-signedness warning:
                 " -1 >  1 ? " << (a >  c) << "\n"
                 "Comparing signed and smaller unsigned:\n"
                 " -1 == 1 ? " << (a == d) << "\n"
                 " -1 <  1 ? " << (a <  d) << "\n"
                 " -1 >  1 ? " << (a >  d) << '\n';
}

Comparing two signed values:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false
Comparing signed and unsigned:
 -1 == 1 ? false
 -1 <  1 ? false
 -1 >  1 ? true
Comparing signed and smaller unsigned:
 -1 == 1 ? false
 -1 <  1 ? true
 -1 >  1 ? false

組み込みポインタ等価比較

等価演算子 == および != の変換されたオペランドは、 std::nullptr_t 型、 (C++11以降) ポインタ型、またはメンバへのポインタ型を持つこともできます。

組み込みポインタの等値比較には、等しい、等しくない、未指定の3つの結果があります。組み込みポインタの等値比較に対する等値演算子が生成する値を以下に示します：

変換後の lhs と rhs の少なくとも一方がポインタの場合、 ポインタ変換 、 関数ポインタ変換 (C++17以降) および 修飾変換 が両方の変換された被演算子に対して実行され、 複合ポインタ型 に変換されます。複合ポインタ型の2つのポインタは以下のように比較されます：

• あるポインタが完全なオブジェクトの アドレス を表し、別のポインタが

• 異なる完全な非配列オブジェクトの終端を超えるアドレスを表す場合、または
• 異なる完全な配列オブジェクトの最後の要素を超えるアドレスを表す場合、

比較結果は未規定です。

• それ以外の場合、両方のポインタがともに null の場合、同じ関数を指している場合、または両方が同じアドレスを表している場合（つまり、同じオブジェクトの終端を指している、または終端を過ぎている場合）、それらは等しいと比較されます。
• それ以外の場合、ポインタは等しくないと比較されます。

変換後の lhs と rhs の少なくとも一方がメンバへのポインタである場合、 メンバポインタ変換 、 関数ポインタ変換 (C++17以降) および 修飾変換 が両方の変換された被演算子に対して実行され、それらを 複合ポインタ型 に変換します。複合ポインタ型の2つのメンバポインタは以下のように比較されます：

• 2つのメンバへのポインタが両方ともヌルメンバポインタ値の場合、それらは等しいと比較される。
• 2つのメンバへのポインタのうち片方のみがヌルメンバポインタ値の場合、それらは等しくないと比較される。
• いずれかが 仮想メンバ関数 へのポインタである場合、結果は未規定である。
• 一方がクラス C1 のメンバを参照し、他方が別のクラス C2 のメンバを参照する場合（互いが互いの基底クラスでない場合）、結果は未規定である。
• 両方が同じ 共用体 の（異なる可能性のある）メンバを参照する場合、それらは等しいと比較される。
• それ以外の場合、2つのメンバへのポインタは、関連するクラス型の仮想的なオブジェクトを用いた間接参照を行った場合に、同じ 最終派生オブジェクト の同じメンバ、または同じ部分オブジェクトを参照するならば等しいと比較され、それ以外の場合は等しくないと比較される。

struct P {};
struct Q : P { int x; };
struct R : P { int x; };
int P::*bx = (int(P::*)) &Q::x;
int P::*cx = (int(P::*)) &R::x;
bool b1 = (bx == cx); // 未規定
struct B
{
    int f();
};
struct L : B {};
struct R : B {};
struct D : L, R {};
int (B::*pb)() = &B::f;
int (L::*pl)() = pb;
int (R::*pr)() = pb;
int (D::*pdl)() = pl;
int (D::*pdr)() = pr;
bool x = (pdl == pdr); // false
bool y = (pb == pl);   // true

組み込みポインタ関係比較

関係演算子 > 、 < 、 >= および <= の変換されたオペランドは、ポインタ型を持つこともできます。

等しくないポインタ p と q に対する組み込みポインタ関係比較には、3つの可能な結果があります： p が大きい、 q が大きい、および未規定。組み込みポインタ関係比較に対する関係演算子が生成する値を以下に示します：

変換された lhs と rhs が両方ともポインタの場合、 ポインタ変換 、 関数ポインタ変換 (C++17以降) および 修飾変換 が両方の変換された被演算子に対して実行され、それらを 複合ポインタ型 に変換します。複合ポインタ型の2つのポインタは以下のように比較されます：

• ポインタが等しいと比較される、または等価比較の結果が未指定の場合、関係比較の結果は同じカテゴリに分類されます。
• それ以外の場合（ポインタが等しくないと比較される）、いずれかのポインタがオブジェクトへのポインタでない場合、結果は未指定です。
• それ以外の場合（両方のポインタがオブジェクトを指している）、結果は以下のルールと整合性のある半順序に基づいて定義されます：

• 配列の2つの異なる要素 high と low が与えられ、 high が low よりも大きい添字を持つ場合、一方のポインタが high （または high の部分オブジェクト）を指し、他方のポインタが low （または low の部分オブジェクト）を指すとき、前者は後者よりも大きいと比較されます。
• 一方のポインタが配列の要素 elem （または elem の部分オブジェクト）を指し、他方のポインタが同じ配列の終端を超えている場合、終端を超えたポインタはもう一方のポインタよりも大きいと比較されます。
• 一方のポインタが完全なオブジェクト、基底クラスの部分オブジェクト、またはメンバー部分オブジェクト obj （または obj の部分オブジェクト）を指し、他方のポインタが obj の終端を超えている場合、終端を超えたポインタはもう一方のポインタよりも大きいと比較されます。

• ポインタが異なる non-zero-sized (since C++20) 非静的データメンバを指し、 同じ member access (until C++23) を持つ非共用体クラス型の同じオブジェクトのメンバ、またはそのようなメンバの部分オブジェクトを再帰的に指す場合、後に宣言されたメンバへのポインタは、もう一方のポインタよりも大きいと比較される。
• それ以外の場合、結果は未規定である。

ポインタ全順序

各プログラムには implementation-defined strict total order over pointers が存在します。このstrict total orderは前述の半順序と整合しています：未規定の結果は実装定義となり、その他の結果は同じまま維持されます。

ポインタの厳密な全順序による比較は以下の場合に適用されます：

• operator ( ) を呼び出すこと std::less 、 std::greater 、 std::less_equal 、および std::greater_equal のポインタ型特殊化の。

オーバーロード

ユーザー定義演算子に対するオーバーロード解決 において、列挙型を含むすべての昇格された算術型のペア L と R について、以下の関数シグネチャがオーバーロード解決に参加します：

`、`$`タグ内のテキストは翻訳対象外\; -\; C++専門用語は翻訳せず保持\; -\; 比較演算子の宣言構文は原文のまま維持$

オブジェクトへのポインタまたは関数へのポインタであるすべての型 P について、以下の関数シグネチャがオーバーロード解決に参加します：

すべてのメンバオブジェクトへのポインタまたはメンバ関数へのポインタである型 MP に対して 、または std::nullptr_t (C++11以降) 、以下の関数シグネチャがオーバーロード解決に参加します：

#include <iostream>
struct Foo
{
    int n1;
    int n2;
};
union Union
{
    int n;
    double d;
};
int main()
{
    std::cout << std::boolalpha;
    char a[4] = "abc";
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements:\n"
              << "p1 == p2? " << (p1 == p2) << '\n'
              << "p1 <  p2? " << (p1 <  p2) << '\n';
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class:\n"
              << "p3 == p4? " << (p3 == p4) << '\n'
              << "p3 <  p4? " << (p3 <  p4) << '\n';
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union:\n"
              << "p5 == (void*)p6? " << (p5 == (void*)p6) << '\n'
              << "p5 <  (void*)p6? " << (p5 <  (void*)p6) << '\n';
}

Pointers to array elements:
p1 == p2? false
p1 <  p2? true
Pointers to members of a class:
p3 == p4? false
p3 <  p4? true
Pointers to members of a union:
p5 == (void*)p6? true
p5 <  (void*)p6? false

#include <compare>
#include <iostream>
int main()
{
    double foo = -0.0;
    double bar = 0.0;
    auto res = foo <=> bar;
    if (res < 0)
        std::cout << "-0 is less than 0";
    else if (res > 0)
        std::cout << "-0 is greater than 0";
    else if (res == 0)
        std::cout << "-0 and 0 are equal";
    else
        std::cout << "-0 and 0 are unordered";
}

-0 and 0 are equal

注記

比較演算子は左から右へグループ化されるため、式 a < b < c は ( a < b ) < c と解析され、 a < ( b < c ) や ( a < b ) && ( b < c ) とはなりません。

#include <iostream>
int main()
{
    int a = 3, b = 2, c = 1;
    std::cout << std::boolalpha
        << (a < b < c) << '\n' // true; 警告が出る可能性あり
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

ユーザー定義の operator< に対する一般的な要件は strict weak ordering です。特に、これは Compare 型を扱う標準アルゴリズムとコンテナによって要求されます： std::sort 、 std::max_element 、 std::map など。

同じクラスの異なる非静的データメンバーへのポインターの 比較結果 は、非静的データメンバーが 3つの メンバーアクセスモード のそれぞれにおいて (C++23まで) 宣言順にメモリに配置されることを示唆します。

ランダムな起源のポインタ（例えば、すべてが同じ配列のメンバを指しているわけではない）を比較した結果は未規定ですが、多くの実装ではポインタの 厳密な全順序 を提供しています（例えば、連続した仮想アドレス空間内のアドレスとして実装されている場合）。そうでない実装（例えば、ポインタのすべてのビットがメモリアドレスの一部ではなく比較時に無視する必要がある場合、追加の計算が必要な場合、あるいはポインタと整数が1対1の関係にない場合）では、その保証を持つポインタ用の std::less の特殊化を提供しています。これにより、ランダムな起源のすべてのポインタを std::set や std::map のような標準の連想コンテナのキーとして使用することが可能になります。

EqualityComparable かつ LessThanComparable の要件を満たす型について、C++標準ライブラリは 等値性 （式 a == b の値）と 同値性 （式 ! ( a < b ) && ! ( b < a ) の値）を区別します。

ポインタとnullポインタ定数との比較は、 CWG issue 583 の解決により削除され、 N3624 に含まれました：

void f(char* p)
{
    if (p > 0) { /*...*/ } // N3624ではエラー、N3624以前はコンパイル可
    if (p > nullptr) { /*...*/ } // N3624ではエラー、N3624以前はコンパイル可
}
int main() {}

三方比較はクラス型に対して自動生成することができます、 デフォルト比較 を参照してください。

両方のオペランドが配列の場合、三方比較は不適格となります。

unsigned int i = 1;
auto r = -1 < i;    // 既存の落とし穴: 'false' を返す
auto r2 = -1 <=> i; // エラー: 縮小変換が必要

標準ライブラリ

比較演算子は標準ライブラリの多くのクラスでオーバーロードされています。

名前空間 std::rel_ops は汎用的な演算子 ! = 、 > 、 <= 、および >= を提供します：

不具合報告

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

関連項目

• 演算子の優先順位
• 演算子のオーバーロード
• Compare (名前付き要件)