名前空間
変種
操作

比較演算子

From cppreference.com
< cpp‎ | language
 
C++
コンパイラサポート
フリースタンディングとホスト
言語
標準ライブラリ
標準ライブラリヘッダー
名前付き要件
機能テストマクロ (C++20)
言語サポートライブラリ
コンセプトライブラリ (C++20)
診断ライブラリ
メモリ管理ライブラリ
メタプログラミングライブラリ (C++11)
汎用ユーティリティライブラリ
コンテナライブラリ
イテレータライブラリ
Rangesライブラリ (C++20)
アルゴリズムライブラリ
文字列ライブラリ
テキスト処理ライブラリ
数値ライブラリ
日付と時刻ライブラリ
入出力ライブラリ
ファイルシステムライブラリ (C++17)
並行サポートライブラリ (C++11)
実行制御ライブラリ (C++26)
Technical specifications (技術仕様)
シンボルインデックス
外部ライブラリ
 
C++言語
全般
フロー制御
条件実行文
if
繰り返し文 (ループ)
for
範囲for文 (C++11)
ジャンプ文
関数
関数宣言
ラムダ式
inline指定子
動的例外仕様 (C++17まで*)
noexcept指定子 (C++11)
例外
名前空間
型
指定子
const/volatile
decltype (C++11)
auto (C++11)
constexpr (C++11)
consteval (C++20)
constinit (C++20)
記憶域期間指定子
初期化
式
代替表現
リテラル
ブーリアン - 整数 - 浮動小数点数
文字 - 文字列 - nullptr (C++11)
ユーザー定義 (C++11)
ユーティリティ
属性 (C++11)
型
typedef宣言
型エイリアス宣言 (C++11)
キャスト
メモリ確保
クラス
クラス固有の関数プロパティ
explicit (C++11)
static

特殊メンバ関数
テンプレート
その他
 
式
全般
リテラル
演算子
型変換
 

引数を比較します。

演算子名  構文  オーバーロード可能 プロトタイプの例 (class T の場合)
クラス定義内 クラス定義外
等しい a == b はい bool T::operator==(const U& b) const; bool operator==(const T& a, const U& b);
等しくない a != b はい bool T::operator!=(const U& b) const; bool operator!=(const T& a, const U& b);
より小さい a < b はい bool T::operator<(const U& b) const; bool operator<(const T& a, const U& b);
より大きい a > b はい bool T::operator>(const U& b) const; bool operator>(const T& a, const U& b);
以下または等しい a <= b はい bool T::operator<=(const U& b) const; bool operator<=(const T& a, const U& b);
以上または等しい a >= b はい bool T::operator>=(const U& b) const; bool operator>=(const T& a, const U& b);
三方向比較 (C++20) a <=> b はい R T::operator<=>(const U& b) const;[1] R operator<=>(const T& a, const U& b);[1]
注釈
  • 組み込み演算子が bool を返す場合、ほとんどの ユーザー定義オーバーロードも bool を返すため、ユーザー定義演算子を組み込み演算子と同じように使用できます。ただし、ユーザー定義演算子オーバーロードでは、任意の型を戻り値の型として使用できます（void を含む）。
  • U は T を含む任意の型にすることができます。
  1. ↑ 1.0 1.1 R は operator<=> の戻り値の型です（下記参照）

目次

[編集] 二方向比較

二方向比較演算子式は次の形式になります。

[編集] 関係演算子
lhs < rhs (1)
lhs > rhs (2)
lhs <= rhs (3)
lhs >= rhs (4)
[編集] 等価演算子
lhs == rhs (5)
lhs != rhs (6)
1) lhs が rhs より小さい場合は true を返し、それ以外の場合は false を返します。
2) lhs が rhs より大きい場合は true を返し、それ以外の場合は false を返します。
3) lhs が rhs 以下である場合は true を返し、それ以外の場合は false を返します。
4) lhs が rhs 以上である場合は true を返し、それ以外の場合は false を返します。
5) lhs が rhs と等しい場合は true を返し、それ以外の場合は false を返します。
6) lhs が rhs と等しくない場合は true を返し、それ以外の場合は false を返します。

[編集] 組み込み二方向比較演算子

組み込み二方向比較演算子の場合、lvalueからrvalueへの変換、配列からポインタへの変換(C++26まで)、および関数からポインタへの変換が lhs と rhs に適用されます。

これらの変換が適用される前に、lhs と rhs の両方が配列型である場合、比較は非推奨となります。

 (C++20以降)
(C++26まで)

組み込み関係演算子の場合、オペランドのいずれかがポインタである場合、もう一方のオペランドに対して配列からポインタへの変換が実行されます。

組み込み等価演算子の場合、オペランドのいずれかがポインタまたはヌルポインタ定数である場合、もう一方のオペランドに対して配列からポインタへの変換が実行されます。

 (C++26以降)

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

[編集] 組み込み算術比較

変換されたオペランドが両方とも算術型または列挙型（scoped または unscoped）である場合、通常の算術変換が両方のオペランドに適用されます。変換後の値が比較されます。

このコードを実行
#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つの結果があります。組み込みポインタ等価比較の等価演算子によって生成される値は次のとおりです。

 比較結果 
p と q の		 によって生成される値
p == q p != q
equal true false
等しくない false true
unspecified  未指定の bool 値 

変換された lhs と rhs の少なくとも一方がポインタである場合、ポインタ変換、関数ポインタ変換(C++17以降)、および修飾変換が両方の変換されたオペランドに適用され、それらを複合ポインタ型に変換します。複合ポインタ型の2つのポインタは次のように比較されます。

  • 一方のポインタが完全なオブジェクトのアドレスを表し、もう一方のポインタが
  • 異なる完全な非配列オブジェクトの終端の次のアドレスを表す場合、または
  • 異なる完全な配列オブジェクトの最後の要素の次のアドレスを表す場合、
比較結果は未指定です。
  • それ以外の場合、ポインタが両方ともヌルである場合、両方とも同じ関数を指す場合、または両方とも同じアドレスを表す場合（つまり、同じオブジェクトを指しているか、その終端の次を指している）、それらは等しく比較されます。
  • それ以外の場合、ポインタは等しくないと比較されます。

変換された 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); // unspecified
 
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

2つのオペランドが std::nullptr_t 型であるか、または一方のオペランドが std::nullptr_t 型で、もう一方がヌルポインタ定数である場合、それらは等しく比較されます。

 (C++11以降)

[編集] 組み込みポインタ関係比較

関係演算子 >, <, >=, <= の変換されたオペランドは、ポインタ型にすることもできます。

異なるポインタ p と q に対する組み込みポインタ関係比較には、p が大きい、q が大きい、および未指定の3つの結果があります。組み込みポインタ関係比較の関係演算子によって生成される値は次のとおりです。

 比較結果 
p と q の		 によって生成される値
 p > q   p < q   p >= q   p <= q 
equal false false true true
p が大きい true false true false
q が大きい false true false true
unspecified 未指定の bool 値

変換された lhs と rhs が両方ともポインタである場合、ポインタ変換、関数ポインタ変換(C++17以降)、および修飾変換が両方の変換されたオペランドに適用され、それらを複合ポインタ型に変換します。複合ポインタ型の2つのポインタは次のように比較されます。

  • ポインタが等しく比較されるか、または等価比較の結果が未指定の場合、関係比較の結果も同じカテゴリに分類されます。
  • それ以外の場合（ポインタが等しくないと比較される）、ポインタのいずれかがオブジェクトへのポインタでない場合、結果は未指定です。
  • それ以外の場合（両方のポインタがオブジェクトを指している）、結果は部分順序に基づいて定義されます。この部分順序は次の規則と一致します。
  • 配列の2つの異なる要素 high と low があり、high の添え字が low より大きい場合、一方のポインタが high（またはそのサブオブジェクト）を指し、もう一方のポインタが low（またはそのサブオブジェクト）を指す場合、前者の方が後者より大きいと比較されます。
  • 一方のポインタが配列の要素 elem（またはそのサブオブジェクト）を指し、もう一方のポインタが同じ配列の終端を過ぎている場合、終端を過ぎたポインタは他のポインタより大きいと（相対的に）比較されます。
  • 一方のポインタが完全なオブジェクト、基底クラスのサブオブジェクト、またはメンバーサブオブジェクト obj（またはそのサブオブジェクト）を指し、もう一方のポインタが obj の終端を過ぎている場合、終端を過ぎたポインタは他のポインタより大きいと（相対的に）比較されます。

  • ポインタが、同じオブジェクトの（おそらく異なる）ゼロ以外のサイズの非静的データメンバー（同じメンバーアクセスを持つ(C++23まで)）を指す場合、またはそのようなメンバーのサブオブジェクトを再帰的に指す場合、後で宣言されたメンバーへのポインタは、他のポインタよりも大きいと（相対的に）比較されます。
  • それ以外の場合、結果は未指定です。

[編集] ポインタの全順序

各プログラムには、実装定義の「ポインタ間の厳密な全順序」が存在します。この厳密な全順序は、前述の部分順序と一致します。未指定の結果は実装定義になり、他の結果はそのまま保持されます。

厳密な全順序によるポインタ比較は、次のケースで適用されます。

(C++14以降)
(C++20以降)

[編集] オーバーロード

オーバーロードされた演算子への呼び出しにおいて、昇格された算術型 L および R（列挙型を含む）のすべてのペアについて、次の関数シグネチャがオーバーロード解決に参加します。

bool operator<(L, R);
bool operator>(L, R);
bool operator<=(L, R);
bool operator>=(L, R);
bool operator==(L, R);
bool operator!=(L, R);

オブジェクトへのポインタまたは関数へのポインタである型 P の場合、次の関数シグネチャがオーバーロード解決に参加します。

bool operator<(P, P);
bool operator>(P, P);
bool operator<=(P, P);
bool operator>=(P, P);
bool operator==(P, P);
bool operator!=(P, P);

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

bool operator==(MP, MP);
bool operator!=(MP, MP);
このコードを実行
#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

三方比較

三方向比較演算子式は次の形式になります。

a <=> b

この式は、次のオブジェクトを返します。

  • (a <=> b) < 0 （a < b の場合）、
  • (a <=> b) > 0 （a > b の場合）、
  • (a <=> b) == 0 （a と b が等しい/同等である場合）。

オペランドのいずれかが bool 型で、もう一方がそうでない場合、プログラムは不正形式となります。

両方のオペランドが算術型である場合、または一方のオペランドが unscoped 列挙型で、もう一方が整数型である場合、通常の算術変換がオペランドに適用され、その後

  • 狭窄変換（整数型から浮動小数点型への変換を除く）が必要な場合、プログラムは不正形式となります。
  • それ以外の場合、オペランドが整数型である場合、演算子は std::strong_ordering 型の prvalue を生成します。
  • std::strong_ordering::equal （両方のオペランドが算術的に等しい場合）、
  • std::strong_ordering::less （最初のオペランドが2番目のオペランドより算術的に小さい場合）、
  • std::strong_ordering::greater （それ以外の場合）。
  • それ以外の場合、オペランドは浮動小数点型であり、演算子は std::partial_ordering 型の prvalue を生成します。a <=> b 式は以下を生成します。
  • std::partial_ordering::less （a が b より小さい場合）、
  • std::partial_ordering::greater （a が b より大きい場合）、
  • std::partial_ordering::equivalent （a が b と同等である場合（-0 <=> +0 は同等）、
  • std::partial_ordering::unordered （NaN <=> anything は順序なし）。

両方のオペランドが同じ列挙型 E を持つ場合、演算子はオペランドを E の基底型に変換し、変換されたオペランドに <=> を適用した結果を生成します。

オペランドの少なくとも一方がオブジェクトへのポインタまたはメンバーへのポインタである場合、配列からポインタへの変換、ポインタ変換、および修飾変換が両方のオペランドに適用され、それらを複合ポインタ型に変換します。

変換されたポインタオペランド p と q に対して、p <=> q は std::strong_ordering 型の prvalue を返します。

  • std::strong_ordering::equal （それらが等しく比較される場合）、
  • std::strong_ordering::less （q が p より大きいと（相対的に）比較される場合）、
  • std::strong_ordering::greater （p が q より大きいと（相対的に）比較される場合）、
  • 未指定の結果（二方向比較の結果が未指定の場合）。

それ以外の場合、プログラムは不適格となります。

オーバーロード

オーバーロードされた演算子への呼び出しにおいて、ポインタ型または列挙型 T について、次の関数シグネチャがオーバーロード解決に参加します。

R operator<=>(T, T);

ここで R は、前述の順序カテゴリ型です。

このコードを実行
#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
 (C++20以降)

[編集] ノート

比較演算子は左から右へグループ化されるため、式 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; maybe warning
        << ((a < b) < c) << '\n' // true
        << (a < (b < c)) << '\n' // false
        << ((a < b) && (b < c)) << '\n'; // false
}

ユーザー定義 operator< に対する一般的な要件は、厳密弱順序です。特に、これは 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) の値である*同等性*を区別します。

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

このコードを実行
void f(char* p)
{
    if (p > 0) { /*...*/ } // Error with N3624, compiled before N3624
    if (p > nullptr) { /*...*/ } // Error with N3624, compiled before N3624
}
 
int main() {}

クラス型の場合、三方向比較は自動生成される可能性があります。詳細はデフォルト比較を参照してください。

両方のオペランドが配列である場合、三方向比較は不正形式となります。

unsigned int i = 1;
auto r = -1 < i;    // existing pitfall: returns ‘false’
auto r2 = -1 <=> i; // Error: narrowing conversion required
機能テストマクロ 値 規格 機能
__cpp_impl_three_way_comparison 201907L (C++20) 三方向比較（コンパイラサポート）
__cpp_lib_three_way_comparison 201907L (C++20) 三方向比較（ライブラリサポート）。ライブラリへの三方向比較の追加。

[編集] 標準ライブラリ

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

(C++20で削除)
 オブジェクトが同じ型を参照しているかを調べる
(std::type_info の public メンバ関数) [編集]
(C++20で削除)(C++20で削除)(C++20)
 2つのerror_codeを比較する
(関数) [編集]
(C++20で削除)(C++20で削除)(C++20)
 error_condition と error_code を比較します
(関数) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 pair内の値を辞書式比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 タプル内の値を辞書順に比較する
(関数テンプレート) [編集]
(C++20で削除)
 内容を比較します。
(std::bitset<N> の public メンバ関数) [編集]
(C++20で削除)
 2つのアロケータインスタンスを比較します。
(std::allocator<T> の public メンバ関数) [編集]
(C++20で削除)(C++20)
 別の unique_ptr または nullptr と比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 別の shared_ptr または nullptr と比較する
(関数テンプレート) [編集]
(C++20で削除)
 std::function と nullptr を比較します。
(関数テンプレート) [編集]
(C++11)(C++11)(C++20で削除)(C++11)(C++11)(C++11)(C++11)(C++20)
 2つの期間を比較する
(関数テンプレート) [edit]
(C++11)(C++11)(C++20で削除)(C++11)(C++11)(C++11)(C++11)(C++20)
 2つの時間点を比較する
(関数テンプレート) [edit]
(C++20で削除)
 2つの scoped_allocator_adaptor オブジェクトを比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20)
 基底の std::type_info オブジェクトを比較します。
(std::type_index の public メンバ関数) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つの文字列を辞書順で比較する
(function template) [編集]
(C++20で削除)
 ロケールオブジェクト間の等価比較。
(std::locale の public メンバ関数) [編集]
(C++11)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++20)
 2つの array の値を辞書式順序で比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つの deque の値を辞書式順序で比較する
(関数テンプレート) [編集]
(C++11)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++11)(C++20で削除)(C++20)
 2つのforward_listの値を辞書順で比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つの list の値を辞書式比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つのvectorの値を辞書式順序で比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つのmapの値を辞書式比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つの multimap の値を辞書式比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つのsetの値を辞書順で比較する
(関数テンプレート) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つのmultisetの値を辞書式比較する
(関数テンプレート) [編集]
(C++11)(C++11)(C++20で削除)
 unordered_map 内の値を比較する
(function template) [編集]
(C++11)(C++11)(C++20で削除)
 unordered_multimap 内の値を比較する
(function template) [編集]
(C++11)(C++11)(C++20で削除)
 unordered_set 内の値を比較する
(function template) [編集]
(C++11)(C++11)(C++20で削除)
 unordered_multiset 内の値を比較する
(function template) [編集]
(C++20)
 2つの queue の値を辞書順に比較する
(関数テンプレート) [編集]
(C++20)
 2つの stack の値を辞書順に比較する
(関数テンプレート) [編集]
(C++20)
 基底イテレータを比較する
(関数テンプレート) [編集]
(C++11)(C++11)(C++20で削除)(C++11)(C++11)(C++11)(C++11)(C++20)
 基底イテレータを比較する
(関数テンプレート) [編集]
(C++20で削除)
 2つの istream_iterator を比較します。
(関数テンプレート) [編集]
(C++20で削除)
 2つのistreambuf_iteratorを比較します
(function template) [編集]
(C++20で削除)
 2つの複素数、または複素数とスカラ値を比較する
(関数テンプレート) [編集]
 2つのvalarray、またはvalarrayと値を比較する
(function template) [編集]
(C++11)(C++11)(C++20で削除)
 2つの擬似乱数エンジンの内部状態を比較します。
(関数) [編集]
(C++11)(C++11)(C++20で削除)
 2つの分布オブジェクトを比較します。
(function) [edit]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 sub_match を別の sub_match、文字列、または文字と比較する
(関数テンプレート) [edit]
(C++20で削除)
 2つのマッチ結果の値を辞書順に比較する
(関数テンプレート) [edit]
(C++20で削除)
 2つの regex_iterator を比較します。
(std::regex_iterator<BidirIt,CharT,Traits> の public メンバ関数) [編集]
(C++20で削除)
 2つの regex_token_iterator を比較します。
(std::regex_token_iterator<BidirIt,CharT,Traits> の public メンバ関数) [編集]
(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20で削除)(C++20)
 2つの thread::id オブジェクトを比較する
(関数) [編集]

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

ヘッダ <utility> で定義
名前空間 std::rel_ops で定義
(C++20で非推奨)
 ユーザー定義の operator== と operator< に基づいて比較演算子を自動的に生成する
(関数テンプレート) [編集]

[編集] 欠陥報告

以下の動作変更を伴う欠陥報告が、以前に公開されたC++標準に遡って適用されました。

DR 適用対象 公開された動作 正しい動作
CWG 583
(N3624)		 C++98 6つの比較演算子すべてを使用して
ポインタとヌルポインタ定数を比較できた		 等価演算子のみ
が許可される
CWG 661 C++98 算術比較の実際の意味（例：
1 < 2 が true または false を生成するかどうか）は未指定だった。		 仕様が追加されました
CWG 879 C++98 関数型へのポインタと
void へのポインタには、組み込み比較がなかった。		 これらのポインタに対する比較
仕様が追加された。
CWG 1596 C++98 非配列オブジェクトは、ポインタ演算の目的で
要素数1の配列に属すると見なされた。		 この規則は、比較にも
適用される。
CWG 1598 C++98 クラスが異なり、どちらも基底クラスではないクラスの
2つのポインタ・トゥ・メンバーは、ポインタ先のメンバーのオフセットが同じであっても、等しく比較されなかった。
オフセットが同じでも		 結果は
unspecified
この場合に
CWG 1858 C++98 同じ共用体の異なるメンバーを参照する2つのポインタ・トゥ・メンバーが、
あたかも同じメンバーを参照しているかのように
等しく比較されるかどうかは不明確だった。		 この場合、それらは
等しく比較される。
CWG 2419 C++98 非配列オブジェクトへのポインタは、ポインタが & によって取得された場合にのみ、
要素数1の配列の最初の要素へのポインタとして扱われた。
非配列オブジェクトへのポインタすべてに		 適用される。
非配列オブジェクトへのポインタすべてに
CWG 2526 C++98 ポインタの（>, >=, <, <=）関係比較の定義が、N3624 によって削除された。
void へのポインタおよび関数ポインタの		 復元されました。
CWG 2796 C++17 組み込みポインタ関係比較中の変換されたポインタオペランドに対して、関数ポインタ変換が実行されなかった。
この場合、それらの		 変換が実行される。
この場合、これらの

[編集] 関連項目

共通の演算子
代入 インクリメント
デクリメント 		算術 論理 比較 メンバ
アクセス 		その他

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
conditional

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://ja.cppreference.dev/mwiki/index.php?title=cpp/language/operator_comparison&oldid=177936" より取得
English 日本語 中文(简体) 中文(繁體)