再谈c++中的variant和visit

一、std::variant

前面把它和volatile对比说明了一下。本文重点说一下他的应用,特别是和它配合的std::visit一起来阐述一下std::variant的用法。optional是从有和无来选择,而variant是在存在的几个类型里任选一个。std::any呢?是一个包含任何类型的单值的类型安全容器。前两个都需要声明类型的范围,后面这个不用。明白了吧。
“类模板 std::variant 表示一个类型安全的联合体。”这句话有点意思,那它和union区别是什么?union是从C时代就有的一个联合体,但是,对象是无法确定到底这个联合体的具体类型。所以在union中产生了很多小技巧,可以让数据来回转换,达到一种数据类型的莫名的变化。可在std::variant这个一旦赋值,对象是知道这个数据类型的;另外,union无法继承,这个倒不是什么多大点的事儿;早期的union只是平凡的数据类型,在c++11后在一些特定条件下,也可以是非平凡的数据。
继续向下看吧,就明白了。

二、应用

1、声明和使用
对std::variant来说,它的声明使用和普通的模板没有什么区别:

//声明
std::variant a,b;
//赋值
a = 10;
b = "test";
a = 1.0f;

//获取值
float tmp = std::get(a);
std::string s = std::get<2>(b);

可以看到在std::variant可以通过类型和索引来获取指定的值。那要是没有这个类型或者索引超范围会是什么样子呢:

int d = std::get(a);
s = std::get<3>(b);

如果索引越界,编译无法通过。但是如果把索引值改了,编译可以通过,这样操作会抛出一个std::bad_variant_access异常。一般来说在c++里尽量少处理异常,所以std::variant提供了一个接口std::get_if:

int *d = std::get_if(&a);
std::string *ss = std::get_if<2>(&b);

std::cout << "d p is:" << d << "  ss p is:" << ss << std::endl;

打印的结果前者是个0值,后者是正常的指针值。

2、 std::visit
看一下它的定义:

template 
constexpr /*see below*/ visit(Visitor&& vis, Variants&&... vars);(1)	(C++17 起)
template 
constexpr R visit(Visitor&& vis, Variants&&... vars) (2)	(C++20 起)


vis: 接受每个 variant 的每个可能可选项的可调用 (Callable) 对象
vars: 传递给观览器的 variant 列表

它就是针对std::variant的更形式化的访问接口。Visitor其实就是一个访问器,也可以理解是一个函数。

#include 
#include 
#include 
#include 
#include 
#include 

// 要观览的 variant
using var_t = std::variant;

// 观览器 #3 的辅助常量
template inline constexpr bool always_false_v = false;

// 观览器 #4 的辅助类型
template struct overloaded : Ts... { using Ts::operator()...; };
// 显式推导指引( C++20 起不需要)
template overloaded(Ts...)->overloaded;

void VisitVar()
{
    std::vector vec = { 10, 15l, 1.5, "hello" };
    for (auto&& v : vec) {
        // 1. void 观览器,仅为其副效应调用
        std::visit([](auto&& arg) {std::cout << arg; }, v);

        // 2. 返回值的观览器,返回另一 variant 的常见模式
        var_t w = std::visit([](auto&& arg) -> var_t {return arg + arg; }, v);

        std::cout << ". After doubling, variant holds ";
        // 3. 类型匹配观览器:亦能为带 4 个重载的 operator() 的类
        std::visit([](auto&& arg) {
            using T = std::decay_t;
            if constexpr (std::is_same_v)
                std::cout << "int with value " << arg << '\n';
            else if constexpr (std::is_same_v)
                std::cout << "long with value " << arg << '\n';
            else if constexpr (std::is_same_v)
                std::cout << "double with value " << arg << '\n';
            else if constexpr (std::is_same_v)
                std::cout << "std::string with value " << std::quoted(arg) << '\n';
            else
                static_assert(always_false_v, "non-exhaustive visitor!");
            }, w);
    }

    for (auto&& v : vec) {
        // 4. 另一种类型匹配观览器:有三个重载的 operator() 的类
        // 注:此情况下 '(auto arg)' 模板 operator() 将绑定到 'int' 与 'long' ,
        //    但若它不存在则 '(double arg)' operator() *亦将* 绑定到 'int' 与 'long' ,
        //    因为两者均可隐式转换成 double 。使用此形式时应留心以正确处理隐式转换。
        std::visit(overloaded{
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; },
            }, v);
    }
}
int main()
{
    VisitVar();
    return 0;
}

3、对对象的支持
在官网还是一般的例程里,都只是对默认类型进行举例说明。其实std::variant是支持对对象操作的,包括继承等。看一下下面的例子:

class A
{
public:
   // A() { std::cout << "call default!" << std::endl; }
    A(int d) { d_ = d; }
private:
    int d_ = 0;
};
void UseObject()
{
    A a;
    std::variant v0;
    std::variant v1{ a };

}
int  main()
{
    UseObject();
    return 0;
}

如果没有默认构造函数或者显示的声明默认构造函数,那么这个是编译不过去的,上面的这个,打开注释就没有问题了。同样,如果把A移到非第一位,也就没问题了。不过在c++中考虑到了这个问题,也就是有强迫非要放在第一位,非要没有默认构造函数(无语,真有如此之人),那么可以用std::monostate来搞定,看它的例程:

void UseObject()
{
    std::variant v0;
    std::cout << "A index:" << v0.index() << std::endl;//此处为0
}
int  main()
{
    UseObject();
    return 0;
}

std::monostate其实是做了一个替补位。但其实如果给这个变量赋值一个A的变量,index就会变成1.这说明这里只是一个编译通过的占位符。“有意为行为良好的 std::variant 中空可选项所用的单位类型。具体而言,非可默认构造的 variant 可以列 std::monostate 为其首个可选项:这使得 variant 自身可默认构造。”

三、总结

对比学习,对比操作会更深刻的体会每一个类和接口的不同,特别是一些细节。正如总是说:“魔鬼在于细节”正是如此。为什么出这几个类?为什么会有操作这些类的接口?可以看一下一些更高级的语言,他们对变量的定义是怎么定义的。比如JS里,变量不定义都可以使。虽然它和c++等的强类型语言有本质的不同,但一些上层的应用可不可以引进一些可以实现的变化,这才是重点。和初学者大谈什么底层,没有意义,只会增加他们对这门语言的畏难情绪。把一些底层和细节封装起来,让初学者更容易接受,更容易使用,这才是王道。
语言再好,没人用,最终也会消亡。不要总沉迷于技术的底层,对于一门语言的发展来说,那些都可以暂时放一放!

你可能感兴趣的:(C++11,c++,开发语言)