C++17完整导引-组件之std::variant

std::variant<std::string> v("abc"); // OK
std::variant<std::string, std::string> w("abc"); // 谬构
std::variant<std::string, const char*> x("abc"); // OK ：选择 const char*
std::variant<std::string, bool> y("abc"); // OK ：选择 string ； bool 不是候选
std::variant<float, long, double> z = 0; // OK ：保有 long
                                         // float 与 double 不是候选
1
2
3
4
5
6

5. 构造一个有指定可选项类型T的 variant 并以参数std::forward(args)...初始化所含值。

template< class T, class... Args >
constexpr explicit variant( std::in_place_type_t<T>, Args&&... args );
1
2

• 若 T 的被选择构造函数是 constexpr 构造函数，则此构造函数亦为 constexpr 构造函数。
• 此重载只有在 Types... 中正好出现一次 T 且std::is_constructible_v为 true 时才会参与重载决议。

6. 构造一个有指定可选项类型 T 的 variant 并以参数il, std::forward(args)...初始化所含值。

template< class T, class U, class... Args >
constexpr explicit variant( std::in_place_type_t<T>,
                            std::initializer_list<U> il, Args&&... args );
1
2
3

• 若 T 的被选择构造函数是 constexpr 构造函数，则此构造函数亦为constexpr构造函数。
• 此重载只有在 Types... 中正好出现一次 T 且 std::is_constructible_v&, Args...> 为true时才会参与重载决议。

7. 构造一个有下标 I 所指定的可选项类型 T_i 的 variant 并以参数std::forward(args)... 初始化所含值。

template< std::size_t I, class... Args >
constexpr explicit variant( std::in_place_index_t<I>, Args&&... args );
1
2

• 若 T_i 的被选择构造函数是 constexpr 构造函数，则此构造函数亦为 constexpr 构造函数。
• 此重载只有在I < sizeof...(Types)与std::is_constructible_v皆为 true 时才会参与重载决议。

8. 构造一个有下标I所指定的可选项类型T_i的 variant 并以参数il, std::forward(args)... 初始化所含值。

template< std::size_t I, class U, class... Args >
constexpr explicit variant( std::in_place_index_t<I>,
                            std::initializer_list<U> il, Args&&... args );
1
2
3

• 若 T_i 的被选择构造函数是constexpr构造函数，则此构造函数亦为constexpr构造函数。
• 此重载只有在 I < sizeof...(Types) 与std::is_constructible_v&, Args...> 皆为true时才会参与重载决议。

示例1 如果传递一个值来初始化，将会使用最佳匹配的类型：

std::variant<long, int> v2{42};
std::cout << v2.index() << '\n';            // 打印出1
1
2

示例2如果有两个类型同等匹配会导致歧义：

std::variant<long, long> v3{42};            // ERROR：歧义
std::variant<int, float> v4{42.3};          // ERROR：歧义
std::variant<int, double> v5{42.3};         // OK
std::variant<int, long double> v6{42.3};    // ERROR：歧义

std::variant<std::string, std::string_view> v7{"hello"};                // ERROR：歧义
std::variant<std::string, std::string_view, const char*> v8{"hello"};   // OK
std::cout << v8.index() << '\n';                                        // 打印出2
1
2
3
4
5
6
7
8

示例3 为了传递多个值来调用构造函数初始化，你必须使用in_place_type或者in_place_index标记：

std::variant<std::complex<double>> v9{3.0, 4.0};    // ERROR
std::variant<std::complex<double>> v10{{3.0, 4.0}}; // ERROR
std::variant<std::complex<double>> v11{std::in_place_type<std::complex<double>>, 3.0, 4.0};
std::variant<std::complex<double>> v12{std::in_place_index<0>, 3.0, 4.0};
1
2
3
4

你也可以使用in_place_index在初始化时解决歧义问题或者打破匹配优先级：

std::variant<int, int> v13{std::in_place_index<1>, 77};     // 初始化第二个int
std::variant<int, long> v14{std::in_place_index<1>, 77};    // 初始化long，而不是int
std::cout << v14.index() << '\n';       // 打印出1
1
2
3

示例4 传递一个带有其他参数的初值列：

// 用一个lambda作为排序准则初始化一个set的variant：
auto sc = [] (int x, int y) {
              return std::abs(x) < std::abs(y);
          };
std::variant<std::vector<int>, std::set<int, decltype(sc)>>
    v15{std::in_place_index<1>, {4, 8, -7, -2, 0, 5}, sc};
1
2
3
4
5
6

示例5 只有当所有初始值都和容器里元素类型匹配时才可以这么做。否则你必须显式传递一个std::initializer_list<>：

// 用一个lambda作为排序准则初始化一个set的variant
auto sc = [] (int x, int y) {
              return std::abs(x) < std::abs(y);
          };
std::variant<std::vector<int>, std::set<int, decltype(sc)>>
    v15{std::in_place_index<1>, std::initializer_list<int>{4, 5L}, sc};
1
2
3
4
5
6

示例6 std::variant<>不支持类模板参数推导，也没有make_variant<>()快捷函数（不像std::optional<>和std::any）。这样做也没有意义，因为variant的目标是处理多个候选项。
如果所有的候选项都支持拷贝，那么就可以拷贝variant对象：

struct NoCopy {
    NoCopy() = default;
    NoCopy(const NoCopy&) = delete;
};

std::variant<int, NoCopy> v1;
std::variant<int, NoCopy> v2{v1};   // ERROR
1
2
3
4
5
6
7

综合示例

#include 
#include 
#include 

int main() {
    // 默认构造
    std::variant<int, float> intFloat;
    std::cout << intFloat.index() << ", value " << std::get<int>(intFloat)
              << "\n";

    // monostate for default initialization:
    class NotSimple {
       public:
        NotSimple(int, float) {}
    };

    // std::variant cannotInit; // error
    std::variant<std::monostate, NotSimple, int> okInit;
    std::cout << okInit.index() << "\n";

    // 传值:
    std::variant<int, float, std::string> intFloatString{10.5f};
    std::cout << intFloatString.index() << ", value "
              << std::get<float>(intFloatString) << "\n";

    // 歧义
    // double 可能会转换为浮点型或 int，因此编译器无法决定
    // std::variant intFloatString { 10.5 };

    // 使用in_place起义
    std::variant<long, float, std::string> longFloatString{
        std::in_place_index<1>, 7.6};  // double!
    std::cout << longFloatString.index() << ", value "
              << std::get<float>(longFloatString) << "\n";

    // in_place 复杂的类型
    std::variant<std::vector<int>, std::string> vecStr{std::in_place_index<0>,
                                                       {0, 1, 2, 3}};
    std::cout << vecStr.index() << ", vector size "
              << std::get<std::vector<int>>(vecStr).size() << "\n";

    // 从其他variant复制初始化:
    std::variant<int, float> intFloatSecond{intFloat};
    std::cout << intFloatSecond.index() << ", value "
              << std::get<int>(intFloatSecond) << "\n";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

运行结果如下：

ASM generation compiler returned: 0
Execution build compiler returned: 0
Program returned: 0
0, value 0
0
1, value 10.5
1, value 7.6
0, vector size 4
0, value 0
1
2
3
4
5
6
7
8
9

访问值

通常的方法是调用get<>()或get_if<>来访问当前选项的值。你可以传递一个索引、或者传递一个类型（该类型的选项只能有一个）。使用一个无效的索引和无效/歧义的类型将会导致编译错误。如果访问的索引或者类型不是当前的选项，将会抛出一个std::bad_variant_access异常。
归结如下：

• 以不匹配当前活跃可选项的下标或类型调用 std::get(std::variant)
• 调用 std::visit 观览因异常无值 (valueless_by_exception) 的 variant

1. get() 函数

template< std::size_t I, class... Types >
constexpr std::variant_alternative_t<I, std::variant<Types...>>&
    get( std::variant<Types...>& v );
1
2
3

• 基于下标的值访问器：若v.index() == I，则返回到存储于v的值的引用。否则抛出 std::bad_variant_access 。若I不是 variant 的合法下标，则此调用为病式。
• 基于类型的值访问器：若 v 保有可选项 T ，则返回到存储于v的值的引用。否则抛出 std::bad_variant_access 。若 T 不是 Types... 中唯一存在的元素，则此调用为病式。

例1：

std::variant<int, int, std::string> var;    // 第一个int设为0，index()==0

auto a = std::get<double>(var);             // 编译期ERROR：没有double类型的选项
auto b = std::get<4>(var);                  // 编译期ERROR：没有第五个选项
auto c = std::get<int>(var);                // 编译期ERROR：有两个int类型的选项

try {
    auto s = std::get<std::string>(var);    // 抛出异常（当前选项是第一个int）
    auto i = std::get<0>(var);              // OK，i==0
    auto j = std::get<1>(var);              // 抛出异常（当前选项是另一个int）
}
catch (const std::bad_variant_access& e) {
    std::cout << "Exception: " << e.what() << '\n';
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

例2：

#include 
#include 
#include 
#include 
#include 

using namespace std;

int main() {
    std::variant<int, float> v{12}, w;
    int i = std::get<int>(v);
    w = std::get<int>(v);
    cout << "w = " << std::get<int>(w) << endl;
    w = std::get<0>(v);  // 效果同前一行
    cout << "w = " << std::get<int>(w) << endl;
    //  std::get(v); // 错误： [int, float] 中无 double
    //  std::get<3>(v);      // 错误：合法的 index 值是 0 和 1

    try {
        std::get<float>(w);  // w 含有 int ，非 float ：将抛出异常
    } catch (std::bad_variant_access& e) {
        cout << "Exception:" << e.what() << endl;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果如下：

w = 12
w = 12
Exception:std::get: wrong index for variant
1
2
3

预处理代码如下：

#include 
#include 
#include 
#include 
#include 

using namespace std;

int main()
{
  std::variant<int, float> v = std::variant<int, float>{12};
  std::variant<int, float> w = std::variant<int, float>();
  int i = std::get<int>(v);
  w.operator=(std::get<int>(v));
  std::operator<<(std::cout, "w = ").operator<<(std::get<int>(w)).operator<<(std::endl);
  w.operator=(std::get<0>(v));
  std::operator<<(std::cout, "w = ").operator<<(std::get<int>(w)).operator<<(std::endl);
  try 
  {
    std::get<float>(w);
  } catch(std::bad_variant_access & e) {
    std::operator<<(std::operator<<(std::cout, "Exception:"), e.what()).operator<<(std::endl);
  }
  ;
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2. get_if() 返回指向存储于被指向的 variant 中值的指针，错误时为空指针。

template< std::size_t I, class... Types >
constexpr std::add_pointer_t<std::variant_alternative_t<I, std::variant<Types...>>>
    get_if( std::variant<Types...>* pv ) noexcept;
1
2
3

• 基于下标的不抛出访问器：若 pv 不是空指针且pv->index() == I，则返回指向存储于 pv 所指向的 variant 中的值的指针。否则，返回空指针值。若 I 不是variant的合法下标，则此调用良构。
• 基于类型的不抛出访问器：I是 T 在Types...中的零基下标。若 T 不是 Types... 中的唯一存在的元素，则此调用非良构。

get_if()可以在访问值之前先检查给定的选项是否是当前选项。

if (auto ip = std::get_if<1>(&var); ip != nullptr) {
    std::cout << *ip << '\n';
}
else {
    std::cout << "alternative with index 1 not set\n";
}
1
2
3
4
5
6

这里还使用了带初始化的if语句，把初始化过程和条件检查分成了两条语句。你也可以直接把初始化语句用作条件语句：

if (auto ip = std::get_if<1>(&var)) {
    std::cout << *ip << '\n';
}
else {
    std::cout << "alternative with index 1 not set\n";
}
1
2
3
4
5
6

示例：

#include 
#include 

int main() {
    std::variant<int, float> v{12};

    if (auto pval = std::get_if<float>(&v))
        std::cout << "variant value: " << *pval << '\n';
    else
        std::cout << "failed to get value!" << '\n';
}
1
2
3
4
5
6
7
8
9
10
11

运行结果

failed to get value!
1

预处理代码

#include 
#include 

int main()
{
  std::variant<int, float> v = std::variant<int, float>{12};
  {
    float * pval = std::get_if<float>(&v);
    if(pval) {
      std::operator<<(std::operator<<(std::cout, "variant value: ").operator<<(*pval), '\n');
    } else {
      std::operator<<(std::operator<<(std::cout, "failed to get value!"), '\n');
    } 
    
  }
  
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

另一种访问不同选项的值的方法是使用variant访问器。

修改值

赋值操作和emplace()函数可以修改值：

std::variant<int, int, std::string> var; // 设置第一个int为0，index()==0
var = "hello";         // 设置string选项，index()==2
var.emplace<1>(42);     // 设置第二个int，index()==1
1
2
3

预处理代码如下：

  std::variant<int, int, std::basic_string<char> > var = std::variant<int, int, std::basic_string<char> >();
  var.operator=("hello");
  var.emplace<1>(42);
1
2
3

注意 operator=将会直接赋予variant一个新值，只要有和新值类型对应的选项。emplace()在赋予新值之前会先销毁旧的值。
你也可以使用get<>()或者get_if<>()来给当前选项赋予新值：

std::variant<int, int, std::string> var; // 设置第一个int为0，index()==0
std::get<0>(var) = 77;                   // OK，但当前选项仍是第一个int
std::get<1>(var) = 99;                   // 抛出异常（因为当前选项是另一个int）

if (auto p = std::get_if<1>(&var); p) {  // 如果第二个int被设置
    *p = 42;                             // 修改值
}
1
2
3
4
5
6
7

std::get<1>(var) = 99; 抛出如下异常：

terminate called after throwing an instance of 'std::bad_variant_access'
  what():  std::get: wrong index for variant
1
2

预处理代码如下：

  std::variant<int, int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > var = std::variant<int, int, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >();
  std::get<0>(var) = 77;
  {
    int * p = std::get_if<1>(&var);
    if(p) {
      *p = 42;
    } 
    
  }
1
2
3
4
5
6
7
8
9

另一个修改不同选项的值的方法是variant访问器。

比较

对两个类型相同的variant（也就是说，它们每个选项的类型和顺序都相同），你可以使用通常的比较运算符。

比较运算将遵循如下规则：

• 当前选项索引较小的小于当前选项索引较大的。
• 如果两个variant当前的选项相同，将调用当前选项类型的比较运算符进行比较。
  注意所有的std::monostate类型的对象都相等。
• 两个variant都处于特殊状态（valueless_by_exception()为真的状态）时相等。否则，valueless_by_exception()返回ture的variant小于另一个。

例如：

#include 
#include 
#include 

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
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

运行结果如下：

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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

预处理代码如下：

#include 
#include 
#include 

int main()
{
  std::cout.operator<<(std::boolalpha);
  std::basic_string<char> cmp = std::basic_string<char>();
  bool result;
    
  class __lambda_10_19
  {
    public: 
    template<class type_parameter_0_0, class type_parameter_0_1>
    inline /*constexpr */ auto operator()(const type_parameter_0_0 & lhs, const type_parameter_0_1 & rhs) const
    {
      (((((((std::cout << lhs) << ' ') << cmp) << ' ') << rhs) << " : ") << result) << '\n';
    }
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ void operator()<int, int>(const int & lhs, const int & rhs) const
    {
      std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::cout.operator<<(lhs), ' '), cmp), ' ').operator<<(rhs), " : ").operator<<(result), '\n');
    }
    #endif
    
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ void operator()<std::basic_string<char>, std::basic_string<char> >(const std::basic_string<char> & lhs, const std::basic_string<char> & rhs) const
    {
      std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::cout, lhs), ' '), cmp), ' '), rhs), " : ").operator<<(result), '\n');
    }
    #endif
    
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ void operator()<std::basic_string<char>, int>(const std::basic_string<char> & lhs, const int & rhs) const
    {
      std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::cout, lhs), ' '), cmp), ' ').operator<<(rhs), " : ").operator<<(result), '\n');
    }
    #endif
    
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ void operator()<int, std::basic_string<char> >(const int & lhs, const std::basic_string<char> & rhs) const
    {
      std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::operator<<(std::cout.operator<<(lhs), ' '), cmp), ' '), rhs), " : ").operator<<(result), '\n');
    }
    #endif
    
    private: 
    std::basic_string<char> & cmp;
    bool & result;
    
    public:
    __lambda_10_19(std::basic_string<char> & _cmp, bool & _result)
    : cmp{_cmp}
    , result{_result}
    {}
    
  };
  
  __lambda_10_19 print2 = __lambda_10_19{cmp, result};
  std::variant<int, std::basic_string<char> > v1 = std::variant<int, std::basic_string<char> >();
  std::variant<int, std::basic_string<char> > v2 = std::variant<int, std::basic_string<char> >();
  std::operator<<(std::cout, "operator==\n");
  {
    cmp.operator=("==");
    result = std::operator==(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=(v2.operator=(1));
    result = std::operator==(v1, v2);
    std::visit(print2, v1, v2);
    v2.operator=(2);
    result = std::operator==(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=("A");
    result = std::operator==(v1, v2);
    std::visit(print2, v1, v2);
    v2.operator=("B");
    result = std::operator==(v1, v2);
    std::visit(print2, v1, v2);
    v2.operator=("A");
    result = std::operator==(v1, v2);
    std::visit(print2, v1, v2);
  };
  std::operator<<(std::cout, "operator<\n");
  {
    cmp.operator=("<");
    v1.operator=(v2.operator=(1));
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v2.operator=(2);
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=(3);
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=("A");
    v2.operator=(1);
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=(1);
    v2.operator=("A");
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=(v2.operator=("A"));
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v2.operator=("B");
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
    v1.operator=("C");
    result = std::operator<(v1, v2);
    std::visit(print2, v1, v2);
  };
  {
    std::variant<int, std::basic_string<char> > v1 = std::variant<int, std::basic_string<char> >();
    std::variant<std::basic_string<char>, int> v2 = std::variant<std::basic_string<char>, int>();
  };
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

move语义

只要所有的选项都支持move语义，那么std::variant<>也支持move语义。
如果你move了variant对象，那么当前状态会被拷贝，而当前选项的值会被move。因此，被move的variant对象仍然保持之前的选项，但值会变为未定义。
你也可以把值移进或移出variant对象。

哈希

如果所有的选项类型都能计算哈希值，那么variant对象也能计算哈希值。注意variant对象的哈希值 不 保证是当前选项的哈希值。在某些平台上它是，有些平台上不是。

访问器

另一个处理variant对象的值的方法是使用访问器(visitor)。访问器是为每一个可能的类型都提供一个函数调用运算符的对象。当这些对象“访问”一个variant时，它们会调用和当前选项类型最匹配的函数。

使用函数对象作为访问器

例如：

#include 
#include 
#include 

struct MyVisitor {
    void operator()(int i) const { std::cout << "int:    " << i << '\n'; }
    void operator()(std::string s) const {
        std::cout << "string: " << s << '\n';
    }
    void operator()(long double d) const {
        std::cout << "double: " << d << '\n';
    }
};
int main() {
    std::variant<int, std::string, long double> var(42);
    std::visit(MyVisitor(), var);  // 调用int的operator()
    var = "hello";
    std::visit(MyVisitor(), var);  // 调用string的operator()
    var = 42.7;
    std::visit(MyVisitor(), var);  // 调用long double的operator()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

预处理代码如下：

struct MyVisitor
{
  inline void operator()(int i) const
  {
    std::operator<<(std::operator<<(std::cout, "int:    ").operator<<(i), '\n');
  }
  
  inline void operator()(std::basic_string<char> s) const
  {
    std::operator<<(std::operator<<(std::operator<<(std::cout, "string: "), s), '\n');
  }
  
  inline void operator()(long double d) const
  {
    std::operator<<(std::operator<<(std::cout, "double: ").operator<<(d), '\n');
  } 
};

int main()
{
  std::variant<int, std::basic_string<char>, long double> var = std::variant<int, std::basic_string<char>, long double>(42);
  std::visit(MyVisitor(), var);
  var.operator=("hello");
  std::visit(MyVisitor(), var);
  var.operator=(42.700000000000003);
  std::visit(MyVisitor(), var);
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

如果访问器没有某一个可能的类型的operator()重载，那么调用visit()将会导致编译期错误，如果调用有歧义的话也会导致编译期错误。
例如：std::variant var(42);代码将无法通过编译。

....
/opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/variant:1032:31: error: no matching function for call to '__invoke(MyVisitor, double&)'
 1032 |           return std::__invoke(std::forward<_Visitor>(__visitor),
      |                  ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 1033 |               __element_by_index_or_cookie<__indices>(
      |               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 1034 |                 std::forward<_Variants>(__vars))...);
      |                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
....
1
2
3
4
5
6
7
8
9

你也可以使用访问器来修改当前选项的值（但不能赋予一个其他选项的新值）。例如：

#include 
#include 
#include 
using namespace std;
struct Twice {
    void operator()(double& d) const { d *= 2; }
    void operator()(int& i) const { i *= 2; }
    void operator()(std::string& s) const { s = s + s; }
};
int main() {
    std::variant<int, std::string, double> var(42);
    std::visit(Twice(), var);  // 调用匹配类型的operator()
    cout << std::get<0>(var);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

访问器调用时只根据类型判断，你不能对类型相同的不同选项做不同的处理。

注意上面例子中的函数调用运算符都应该标记为const，因为它们是 无状态的(stateless) （它们的行为只受参数的影响）。

使用泛型lambda作为访问器

最简单的使用访问器的方式是使用泛型lambda，它是一个可以处理任意类型的函数对象：

#include 
#include 
#include 

using namespace std;

int main() {
    auto pp = [] (const auto& val) {
                        std::cout << val << '\n';
                    };
    std::variant<int> var(42);
    std::visit( pp, var);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

这里，泛型lambda生成的闭包类型中会将函数调用运算符定义为模板：

class ComplierSpecificClosureTypeName {
public:
    template<typename T>
    auto operator() (const T& val) const {
        std::cout << val << '\n';
    }
};
1
2
3
4
5
6
7

因此，只要调用时生成的函数内的语句有效（这个例子中就是输出运算符要有效），那么把lambda传递给std::visit()就可以正常编译。
预处理代码如下：

#include 
#include 
#include 

using namespace std;

int main()
{
    
  class __lambda_8_15
  {
    public: 
    template<class type_parameter_0_0>
    inline /*constexpr */ auto operator()(const type_parameter_0_0 & val) const
    {
      operator<<(operator<<(std::cout, val), '\n');
    }
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ void operator()<int>(const int & val) const
    {
      std::operator<<(std::cout.operator<<(val), '\n');
    }
    #endif
    
    private: 
    template<class type_parameter_0_0>
    static inline /*constexpr */ auto __invoke(const type_parameter_0_0 & val)
    {
      return __lambda_8_15{}.operator()<type_parameter_0_0>(val);
    }
    
  };
  
  __lambda_8_15 pp = __lambda_8_15{};
  std::variant<int> var = std::variant<int>(42);
  std::visit(pp, var);
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

你也可以使用lambda来修改当前选项的值：

#include 
#include 
#include 

using namespace std;

int main() {
    auto pp = [](auto& val) {
        std::cout << val << '\n'
        val = val + val;
    };
    std::variant<int> var(42);
    std::visit(pp, var);//输出42
    cout << std::get<0>(var) << endl; // 输出84
    // 将当前选项的值变为两倍：
    std::visit([](auto& val) { val = val + val; }, var);
    cout << std::get<0>(var) << endl;//输出168
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

或者：

#include 
#include 
#include 

using namespace std;

int main() {
    std::variant<int> var(42);
    // 将当前选项的值设为默认值
    std::visit(
        [](auto& val) { val = std::remove_reference_t<decltype(val)>{}; }, var);
    cout << std::get<0>(var) << endl; //输出0
}
1
2
3
4
5
6
7
8
9
10
11
12
13

你甚至可以使用编译期if语句来对不同的选项类型进行不同的处理。例如：

#include 
#include 
#include 

using namespace std;

int main() {
    auto dblvar = [](auto& val) {
        if constexpr (std::is_convertible_v<decltype(val), std::string>) {
            val = val + val;
        } else {
            val *= 2;
        }
    };
    std::variant<int> var(42);
    std::visit(dblvar, var);
    cout << std::get<0>(var) << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

预处理代码如下：

using namespace std;

int main()
{
    
  class __lambda_8_19
  {
    public: 
    template<class type_parameter_0_0>
    inline /*constexpr */ auto operator()(type_parameter_0_0 & val) const
    {
      if constexpr(std::is_convertible_v<decltype(val), std::basic_string<char> >) {
        val = operator+(val, val);
      } else /* constexpr */ {
        val = static_cast<type_parameter_0_0>(static_cast<<dependent type>>(val) * 2);
      } 
      
    }
    
    #ifdef INSIGHTS_USE_TEMPLATE
    template<>
    inline /*constexpr */ void operator()<int>(int & val) const
    {
      if constexpr(false) {
      } else /* constexpr */ {
        val = static_cast<int>(val * 2);
      } 
      
    }
    #endif
    
    private: 
    template<class type_parameter_0_0>
    static inline /*constexpr */ auto __invoke(type_parameter_0_0 & val)
    {
      return __lambda_8_19{}.operator()<type_parameter_0_0>(val);
    }
    
  };
  __lambda_8_19 dblvar = __lambda_8_19{};
  std::variant<int> var = std::variant<int>(42);
  std::visit(dblvar, var);
  std::cout.operator<<(std::get<0>(var)).operator<<(std::endl);
  return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

这里，对于std::string类型的选项，泛型lambda会把函数调用模板实例化为计算：

val = val + val;
1

而对于其他类型的选项，例如int或double，lambda函数调用模板会实例化为计算：

val *= 2;
1

注意检查val的类型时必须小心。这里，我们检查了val的类型是否能转换为std::string。如下检查：

if constexpr(std::is_same_v<decltype(val), std::string>) {
1

将不能正确工作，因为val的类型只可能是int&、std::string&、long double&这样的引用类型。

在访问器中返回值

访问器中的函数调用可以返回值，但所有返回值类型必须相同。例如：

#include 
#include 
#include 
#include 

using namespace std;

int main() {
    using IntOrDouble = std::variant<int, double>;

    std::vector<IntOrDouble> coll{42, 7.7, 0, -0.7};

    double sum{0};
    for (const auto& elem : coll) {
        sum += std::visit(
            [](const auto& val) -> double {
                cout << val << endl;
                return val;
            },
            elem);
    }
    cout << sum << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果如下：

42
7.7
0
-0.7
49
1
2
3
4
5

上面的代码会把所有选项的值加到sum上。如果lambda中没有显式指明返回类型将不能通过编译，因为自动推导的话返回类型会不同。

使用重载的lambda作为访问器

通过使用函数对象和lambda的 重载器(overloader) ，可以定义一系列lambda，其中最佳的匹配将会被用作访问器。

假设有一个如下定义的overload重载器：

// 继承所有基类里的函数调用运算符
template<typename... Ts>
struct overload : Ts...
{
    using Ts::operator()...;
};

// 基类的类型从传入的参数中推导
template<typename... Ts>
overload(Ts...) -> overload<Ts...>;
1
2
3
4
5
6
7
8
9
10

你可以为每个可能的选项提供一个lambda，之后使用overload来访问variant：

std::variant<int, std::string> var(42);
...
std::visit(overload { // 为当前选项调用最佳匹配的lambda
               [](int i) { std::cout << "int: " << i << '\n'; },
               [] (const std::string& s) {
               std::cout << "string: " << s << '\n';
           },
       }, var);
1
2
3
4
5
6
7
8

你也可以使用泛型lambda，它可以匹配所有情况。例如，要想修改一个variant当前选项的值，你可以使用重载实现字符串和其他类型值“翻倍”：

auto twice = overload {
                 [] (std::string& s) { s += s; },
                 [] (auto& i) { i *= 2; },
             };
1
2
3
4

使用这个重载，对于字符串类型的选项，值将变为原本的字符串再重复一遍；而对于其他类型，将会把值乘以2。下面展示了怎么应用于variant：

std::variant<int, std::string> var(42);
std::visit(twice, var); // 值42变为84
...
var = "hi";
std::visit(twice, var); // 值"hi"变为"hihi"
1
2
3
4
5

示例：

// visitVariantsOverloadPattern.cpp

#include 
#include 
#include 
#include 
#include 

template<typename ... Ts>                                                 // (7) 
struct Overload : Ts ... { 
    using Ts::operator() ...;
};
template<class... Ts> Overload(Ts...) -> Overload<Ts...>;

int main(){
  
    std::cout << '\n';
  
    std::vector<std::variant<char, long, float, int, double, long long>>  // (1)    
               vecVariant = {5, '2', 5.4, 100ll, 2011l, 3.5f, 2017};

    auto TypeOfIntegral = Overload {                                      // (2)
        [](char) { return "char"; },
        [](int) { return "int"; },
        [](unsigned int) { return "unsigned int"; },
        [](long int) { return "long int"; },
        [](long long int) { return "long long int"; },
        [](auto) { return "unknown type"; },
    };
  
    for (auto v : vecVariant) {                                           // (3)
        std::cout << std::visit(TypeOfIntegral, v) << '\n';
    }

    std::cout << '\n';

    std::vector<std::variant<std::vector<int>, double, std::string>>      // (4)
        vecVariant2 = { 1.5, std::vector<int>{1, 2, 3, 4, 5}, "Hello "};

    auto DisplayMe = Overload {                                           // (5)
        [](std::vector<int>& myVec) { 
                for (auto v: myVec) std::cout << v << " ";
                std::cout << '\n'; 
            },
        [](auto& arg) { std::cout << arg << '\n';},
    };

    for (auto v : vecVariant2) {                                         // (6)
        std::visit(DisplayMe, v);
    }

    std::cout << '\n';
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54