名稱空間
變體
操作

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

來自 cppreference.com
< cpp‎ | utility‎ | variant
 
C++
 
工具庫
通用工具
關係運算符 (C++20 中棄用)
 
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) 比較兩個 std::variant 物件 lhs 和 rhs。僅當 lhs 和 rhs 都包含對應相同索引的值時，才比較其包含的值（使用 T 的相應運算子）。否則，
  • 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 - 要比較的變體

[編輯] 返回值

 運算子  兩個運算元都包含一個值
（令 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 = "==";
 
        // by default 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; // Compilation error: no known conversion
    }
 
    // TODO: C++20 three-way comparison operator <=> for variants
}

輸出

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 物件
(函式模板) [編輯]
取自 "https://cppreference.tw/mwiki/index.php?title=cpp/utility/variant/operator_cmp&oldid=179395"