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。只有在 lhs 和 rhs 都含值且对应索引相同时才会（使用 T 的对应运算符）比较所含值。否则，
  • 当且仅当 lhs 与 rhs 都不含值时，才认为 lhs 等于 rhs。
  • 当且仅当 rhs 含值且 lhs 不含值，或者 lhs.index() 小于 rhs.index() 时，才认为 lhs 小于 rhs。
1-6) 以 @ 表示对应的比较运算符，对于每个函数：

如果对应的表达式 GET <I>(lhs) @ GET <I>(rhs) 对于某些 I 值非良构或它的结果不可转换到 bool，那么程序非良构。

(C++26 前)

此重载只有在对应的表达式 GET <I>(lhs) @ GET <I>(rhs) 对于所有 I 值良构且它的结果可转换到 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 = "==";
 
        // 默认为 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 用于变体的三路比较运算符 <=>
}

输出： 

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://zh.cppreference.com/mwiki/index.php?title=cpp/utility/variant/operator_cmp&oldid=97549”