C++17之std::visit

    它们必须明确地为每种可能的类型提供函数调用操作符。然后&＃xff0c;使用相应的重载来处理当前的备选项类型。

1. 使用对象函数方式访问

例1&＃xff1a;

#include
#include
#include struct MyVisitor
{void operator()(double d) const {std::cout <}
};
int main()
{std::variant var1(42), var2(3.14), var3("visit");std::visit(MyVisitor(), var1); // calls operator() for matching int typestd::visit(MyVisitor(), var2); // calls operator() for matching double typestd::visit(MyVisitor(), var3); // calls operator() for matching std::string typereturn 0;
}

结果如下&＃xff1a;

 如果操作符()不支持所有可能的类型&＃xff0c;或者调用不明确&＃xff0c;则visit()调用是编译时错误。还可以使用访问者修改当前类型的值(但不能分配新类型的值)。

例2&＃xff1a;

#include
#include
#include struct Twice
{void operator()(double& d) const {d *&＃61; 2;}void operator()(int& i) const {i *&＃61; 2;}void operator()(std::string& s) const {s &＃61; s &＃43; s;}
};int main()
{std::variant var1(42), var2(3.14), var3("visit");std::visit(Twice(), var1); // calls operator() for matching int typestd::visit(Twice(), var2); // calls operator() for matching double typestd::visit(Twice(), var3); // calls operator() for matching std::string typestd::cout <(var1) <(var2) <(var3) <}

结果如下&＃xff1a;

注意&＃xff0c;对象操作符应该为const函数&＃xff0c;因为它们是无状态的(它们不改变它们的行为&＃xff0c;只改变传递的值&＃xff0c;即不改变成员变量的值)。 

 2. 使用泛型Lambdas访问

使用这个特性最简单的方法是使用泛型lambda&＃xff0c;它是一个函数对象&＃xff0c;用于任意类型:

例3&＃xff1a;

#include
#include
#include auto printvariant &＃61; [](const auto& val)
{std::cout <};int main()
{std::variant var1(42), var2(3.14), var3("visit");std::visit(printvariant, var1);std::visit(printvariant, var2);std::visit(printvariant, var3);return 0;
}

结果如下&＃xff1a;

 这里&＃xff0c;泛型lambda定义了一个闭包类型&＃xff0c;其中函数调用操作符作为成员模板:

class CompilerSpecifyClosureTypeName
{
public:
template
auto operator() (const T& val) const
{std::cout <}
};

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

例4&＃xff1a;

#include
#include
#include auto printvariant &＃61; [](const auto& val)
{std::cout <};int main()
{std::variant var1(42), var2(3.14), var3("visit");std::visit([](auto& val) {val &＃61; val &＃43; val;},var1);std::visit([](auto& val) {val &＃61; val &＃43; val;},var2);std::visit([](auto& val) {val &＃61; val &＃43; val;},var3);std::visit(printvariant, var1);std::visit(printvariant, var2);std::visit(printvariant, var3);return 0;
}

结果如下&＃xff1a;

甚至可以使用编译时if语言特性以不同的方式处理不同的备选值&＃xff1a;

例5&＃xff1a;

#include
#include
#include auto dblvar &＃61; [](auto& val)
{if constexpr (std::is_convertible_v){val &＃61; val &＃43; " test";}else{val &＃43;&＃61; 2;}
};int main()
{std::variant var1(42), var2(3.14), var3("visit");std::visit(dblvar, var1);std::visit(dblvar, var2);std::visit(dblvar, var3);std::cout <(var1) <(var2) <(var3) <}

这里&＃xff0c;对于一个std::string类型备选项&＃xff0c;泛型lambda的调用实例化它的泛型函数调用模板来计算:

val &＃61; val &＃43; “ test”;

而对于其他类型备选项&＃xff0c;如int或double, lambda的调用实例化其通用函数调用模板来计算:

val &＃43;&＃61; 2;

结果如下&＃xff1a;

3. 使用重载的Lambdas来访问

通过为函数对象和lambdas使用一个重载器&＃xff0c;还可以定义一组lambdas&＃xff0c;其中使用最佳匹配作为访问者。假设&＃xff0c;重载器定义为重载&＃xff0c;如下所示&＃xff1a;

template
struct overload : Ts...
{
using Ts::operator()...;
};
// base types are deduced from passed arguments:
template
overload(Ts...) -> overload;

可以使用重载访问一个变量&＃xff0c;为每个选项提供lambdas:

std::variant var(42);
...
std::visit(overload{ // calls best matching lambda for current alternative
[](int i) { std::cout <<"int: " <[](const std::string& s) {
std::cout <<"string: " <},
var);

还可以使用泛型lambda。总是用最好的搭配。例如&＃xff0c;要修改variant对象的当前类型备选项的值&＃xff0c;可以使用重载将字符串和其他类型的值“加倍”&＃xff1a;

auto twice &＃61; overload{
[](std::string& s) { s &＃43;&＃61; s; },
[](auto& i) { i *&＃61; 2; },
};

    使用此重载&＃xff0c;对于字符串类型备选项&＃xff0c;将添加当前值&＃xff0c;而对于所有其他类型&＃xff0c;将值乘以2&＃xff0c;这演示了variant对象的以下应用程序:

std::variant var(42);
std::visit(twice, var); // value 42 becomes 84
...
var &＃61; "hi";
std::visit(twice, var); // value "hi" becomes "hihi"

例 6&＃xff1a;

#include
#include
#include template
struct overload : Ts...
{using Ts::operator()...;
};template
overload(Ts...)->overload;auto twice &＃61; overload{[](std::string& s) { s &＃43;&＃61; s; },[](auto& i) { i *&＃61; 2; },
};int main()
{std::variant var1(42) , var3("visit");std::visit(twice, var1);std::visit(twice, var3);std::visit(overload{ // calls best matching lambda for current alternative[](int i) { std::cout <<"int: " <}

结果如下&＃xff1a;