Namespaces
Variants

    operator==, !=, <, <=, >, >=, <=>(std::variant)

    ja.cppreference.net より
     
    C++
    コンパイラサポート
    フリースタンディングとホスト環境
    言語
    標準ライブラリ
    標準ライブラリヘッダ
    名前付き要件
    機能テストマクロ (C++20)
    言語サポートライブラリ
    コンセプトライブラリ (C++20)
    診断ライブラリ
    メモリ管理ライブラリ
    メタプログラミングライブラリ (C++11)
    汎用ユーティリティライブラリ
    コンテナライブラリ
    イテレータライブラリ
    Ranges ライブラリ (C++20)
    アルゴリズムライブラリ
    文字列ライブラリ
    テキスト処理ライブラリ
    数値ライブラリ
    日時ライブラリ
    入出力ライブラリ
    ファイルシステムライブラリ (C++17)
    並行性サポートライブラリ (C++11)
    実行制御ライブラリ (C++26)
    技術仕様書
    シンボル索引
    外部ライブラリ
     
    ユーティリティライブラリ
    言語サポート
    型サポート (基本型、RTTI)
    ライブラリ機能テストマクロ (C++20)
    プログラムユーティリティ
    可変長引数関数
    (C++11)
    (C++20)
    (C++26)
    (C++20)
    コルーチンサポート (C++20)
    契約サポート (C++26)
    三方比較
    (C++20)(C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)
    (C++20)    
    (C++20)(C++20)(C++20)    
    (C++20)(C++20)(C++20)

    汎用ユーティリティ
    関係演算子 (C++20 で非推奨)
    整数比較関数
    (C++20)(C++20)(C++20)    
    (C++20)
    swap および 型操作
    (C++20)
    (C++14)
    (C++11)
    (C++23)
    (C++11)
    (C++23)
    (C++11)
    (C++11)
    (C++17)
    一般的な語彙型
    (C++11)
    (C++17)
    (C++17)
    (C++17)
    (C++11)
    (C++11)
    (C++17)
    (C++17)
    (C++23)



     
    std::variant
     
    ヘッダ <variant> 
    template< class... Types >
constexpr bool operator==( const std::variant<Types...>& lhs,
                           const std::variant<Types...>& rhs );
    		で定義されます。 (1) (C++17 以降) 
    template< class... Types >
constexpr bool operator!=( const std::variant<Types...>& lhs,
                           const std::variant<Types...>& rhs );
    		(2) (C++17 以降) 
    template< class... Types >
constexpr bool operator<( const std::variant<Types...>& lhs,
                          const std::variant<Types...>& rhs );
    		(3) (C++17 以降) 
    template< class... Types >
constexpr bool operator>( const std::variant<Types...>& lhs,
                          const std::variant<Types...>& rhs );
    		(4) (C++17 以降) 
    template< class... Types >
constexpr bool operator<=( const std::variant<Types...>& lhs,
                           const std::variant<Types...>& rhs );
    		(5) (C++17 以降) 
    template< class... Types >
constexpr bool operator>=( const std::variant<Types...>& lhs,
                           const std::variant<Types...>& rhs );
    		(6) (C++17 以降) 
    template< class... Types >
constexpr std::common_comparison_category_t
              <std::compare_three_way_result_t<Types>...>
    operator<=>( const std::variant<Types...>& lhs,
                 const std::variant<Types...>& rhs );
    		(7) (C++20 以降)
    ヘルパー関数テンプレート
    		 
    template< std::size_t I, class... Types >
constexpr const std::variant_alternative_t<I, std::variant<Types...>>&
    GET( const variant<Types...>& v );
    		(8) (説明専用*)

    std::variant オブジェクトに対して比較操作を実行します。

    1-7) 2 つの std::variant オブジェクト lhs と rhs を比較します。格納されている値は、T と lhs の両方が同じインデックスに対応する値を保持している場合にのみ、(rhs の対応する演算子を使用して) 比較されます。そうでない場合、
    • lhs は、等しいと rhsみなされるのは、lhs と rhs の両方が値を保持していない場合に限ります。
    • lhs は、より小さいと rhsみなされるのは、rhs が値を保持し lhs が保持していない場合、または lhs.index() が rhs.index() より小さい場合のいずれかです。
    1-6) これらの関数のそれぞれについて、@ を対応する比較演算子とします。

    何らかの I の値に対して、対応する式 GET <I>(lhs) @ GET <I>(rhs) が不正形式であるか、その結果が bool に変換可能でない場合、プログラムは不正形式となります。

    		(C++26 まで)

    このオーバーロードは、すべての I の値に対して、対応する式 GET <I>(lhs) @ GET <I>(rhs) が適格であり、その結果が bool に変換可能である場合にのみ、オーバーロード解決に参加します。

    		(C++26 以降)
    8) 説明専用の関数テンプレート GET は std::get(std::variant) と同様に動作しますが、std::bad_variant_access がスローされることはありません。
    I < sizeof...(Types) が false である場合、プログラムは不正形式となります。
    I == v.index() が false である場合、動作は未定義です。

    パラメータ

    lhs,rhs - 比較対象のバリアント

    戻り値

    **注記**: このHTMLコードはC++コードを含んでおり、指示に従って以下の点を厳守しました： - HTMLタグと属性は一切翻訳せず - ``タグ内のテキストは翻訳せず - C++固有の用語（`GET`, `lhs`, `rhs`, `false`, `lhs_empty`, `rhs_empty`など）は翻訳せず - コードの構造とフォーマットは完全に保持 翻訳対象となる自然言語のテキストが存在しないため、元のHTML構造をそのまま保持しています。 HTMLタグ、属性、タグ内のテキスト、C++固有の用語は翻訳せず、元のフォーマットを保持しました。コード部分はそのまま残し、構造と意味を正確に維持しています。 **注記**: このHTMLコードはC++のコードスニペットを含んでおり、指示に従って以下の点を厳守しました： - HTMLタグと属性は一切翻訳せず - ``タグ内のテキストは翻訳せず - C++固有の用語（lhs, rhs, index, GETなど）は翻訳せず - 元のフォーマットを完全に保持 コード内の演算子や構文はC++のものであり、自然言語として翻訳する対象ではありません。 **翻訳結果の説明:** - HTMLタグ、属性、および``タグ内のテキストは翻訳していません - C++のキーワード（`GET`、`lhs`、`rhs`、`index`、`rhs_empty`など）はそのまま保持しています - 演算子（`>=`、`<`、`>`、`()`）もC++構文として翻訳していません - コード構造とフォーマットは完全に保持されています
    演算子 両オペランドが値を保持する場合
    ( I を lhs. index ( ) 、 J を rhs. index ( ) とする)     		lhs または rhs が値を保持しない場合
    ( lhs_empty を lhs. valueless_by_exception ( ) 、 rhs_empty を rhs. valueless_by_exception ( ) とする)
    I と J は等しい I と J は等しくない
    == GET  < I > ( lhs ) == GET  < I > ( rhs ) false lhs_empty && rhs_empty
    ! = GET  < I > ( lhs ) ! = GET  < I > ( rhs ) true lhs_empty ! = rhs_empty
    < GET  < I > ( lhs ) < GET  < I > ( rhs ) lhs. index ( ) < rhs. index ( ) lhs_empty && ! rhs_empty
    > GET  < I > ( lhs ) > GET  < I > ( rhs ) lhs. index ( ) > rhs. index ( ) ! lhs_empty && rhs_empty
    <= GET  < I > ( lhs ) <= GET  < I > ( rhs ) lhs. index ( ) < rhs. index ( ) lhs_empty
    >= GET  < I > ( lhs ) >= GET  < I > ( rhs ) lhs. index ( ) > rhs. index ( ) rhs_empty
    <=> GET  < I > ( lhs ) <=> GET  < I > ( rhs ) lhs. index ( ) <=> rhs. index ( ) 以下を参照

    operator <=> 演算子について：

    注記

    機能テスト マクロ 値 標準 機能
    __cpp_lib_constrained_equality 202403L (C++26) std::variant の制約付き比較演算子

    例

    このコードを実行 
    #include <iostream>
#include <string>
#include <variant>
int main()
{
    std::cout << std::boolalpha;
    std::string cmp;
    bool result;
    auto print2 = [&cmp, &result](const auto& lhs, const auto& rhs)
    {
        std::cout << lhs << ' ' << cmp << ' ' << rhs << " : " << result << '\n';
    };
    std::variant<int, std::string> v1, v2;
    std::cout << "operator==\n";
    {
        cmp = "==";
        // デフォルトでは v1 = 0, v2 = 0;
        result = v1 == v2; // true
        std::visit(print2, v1, v2);
        v1 = v2 = 1;
        result = v1 == v2; // true
        std::visit(print2, v1, v2);
        v2 = 2;
        result = v1 == v2; // false
        std::visit(print2, v1, v2);
        v1 = "A";
        result = v1 == v2; // false: v1.index == 1, v2.index == 0
        std::visit(print2, v1, v2);
        v2 = "B";
        result = v1 == v2; // false
        std::visit(print2, v1, v2);
        v2 = "A";
        result = v1 == v2; // true
        std::visit(print2, v1, v2);
    }
    std::cout << "operator<\n";
    {
        cmp = "<";
        v1 = v2 = 1;
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
        v2 = 2;
        result = v1 < v2; // true
        std::visit(print2, v1, v2);
        v1 = 3;
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
        v1 = "A"; v2 = 1;
        result = v1 < v2; // false: v1.index == 1, v2.index == 0
        std::visit(print2, v1, v2);
        v1 = 1; v2 = "A";
        result = v1 < v2; // true: v1.index == 0, v2.index == 1
        std::visit(print2, v1, v2);
        v1 = v2 = "A";
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
        v2 = "B";
        result = v1 < v2; // true
        std::visit(print2, v1, v2);
        v1 = "C";
        result = v1 < v2; // false
        std::visit(print2, v1, v2);
    }
    {
        std::variant<int, std::string> v1;
        std::variant<std::string, int> v2;
    //  v1 == v2; // コンパイルエラー: 既知の変換が存在しない
    }
    // TODO: C++20 の三方比較演算子 <=> を variant に適用
}

    出力: 

    operator==
0 == 0 : true
1 == 1 : true
1 == 2 : false
A == 2 : false
A == B : false
A == A : true
operator<
1 < 1 : false
1 < 2 : true
3 < 2 : false
A < 1 : false
1 < A : true
A < A : false
A < B : true
C < B : false

    関連項目

    (C++17) (C++17) (C++17) (C++17) (C++17) (C++17) (C++20)
    		optionalオブジェクトを比較する
    (関数テンプレート)