C++访问std::variant类型数据的几种方式

前言

std::variant(可变体) 是 C++17 中引入的一个新的类模板,提供了一种存储不同类型的值的方式,类似于之前版本中的 union(联合体),但可以存储非 POD 类型和类对象,能够在运行时进行类型检查和转换,但具有更多的功能和更高的类型安全性,今天来看一下存储在std::variant中的数据要怎么读取。

variant的简单使用

可以参考cppreference网站的使用示例,也可以看看下面这个例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <iostream>
#include <variant>
#include <string>

int main()
{
std::variant<int, double, std::string> value;

value = 110;
std::cout << "The value is an integer: " << std::get<int>(value) << std::endl;

value = 0.618;
std::cout << "The value is a double: " << std::get<double>(value) << std::endl;

value = "hello world";
std::cout << "The value is a string: " << std::get<std::string>(value) << std::endl;

// value = true; // Compilation error: cannot convert type bool to any of the alternative types
// std::get<int>(value) // std::bad_variant_access exception: value holds a different type

return 0;
}

在示例程序中,定义了一个 std::variant 对象 value 来存储整型、浮点型和字符串类型中的任意一种,然后分别将 value 赋值为整型、浮点型和字符串类型,并使用 std::get 来获取对应的值,此时可以正常打印 value 对象中存储的值

当我们试图将 value 赋值为其它未在定义变量时指定的类型时,编译器将会报编译错误,而当我我们试图获取 value 中不存在的类型的值时,程序将会抛出 std::bad_variant_access 异常,可以使用 try-catch 已经捕获。

通过这段代码我们可以得知,使用std::variant可以方便地存储多种类型的数据,并且能够在运行时进行类型检查和转换,这使得代码更加清晰易读,便于维护。

variant相关函数和类

  • 成员函数
    • index:返回 variant 中保存用类型的索引下标
    • valueless_by_exception:返回 variant 是否处于因异常导致的无值状态
    • emplace:原位构造 variant 中的值
  • 非成员函数
    • visit:通过调用variant保存类型值所提供的函数对象获取具体值
    • holds_alternative:检查某个 variant 是否当前持有某个给定类型
    • std::get:以给定索引或类型读取 variant 的值,错误时抛出异常
    • get_if:以给定索引或类型,获得指向被指向的 variant 的值的指针,错误时返回空指针
  • 辅助类
    • monostate:用作非可默认构造类型的 variant 的首个可选项的占位符类型(预防一些类型不提供无参构造函数)
    • bad_variant_access:非法地访问 variant 的值时抛出的异常
    • variant_npos:非法状态的 variant 的下标

访问std::variant数据

从前面提到的例子和函数说明,我们可以看到有多种方式来访问std::variant数据,接一下来一起总结一下:

std::get搭配index函数使用

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <variant>

int main()
{
std::variant<double, int> value = 119;

if (1 == value.index())
std::cout << "The value is: " << std::get<1>(value) << std::endl;

return 0;
}

先用 index() 查询 variant保存的类型索引,然后在通过 std::get<NUMBER>() 获取其中的值

std::get搭配std::holds_alternative函数使用

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <variant>

int main()
{
std::variant<double, int> value = 119;

if (std::holds_alternative<int>(value))
std::cout << "The value is: " << std::get<int>(value) << std::endl;

return 0;
}

先通过 std::holds_alternative() 查询 variant保存的类型,然后在通过 std::get<TYPE>() 获取其中的值

std::get_if函数

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <variant>

int main()
{
std::variant<double, int> value = 119;

if (auto p = std::get_if<int>(&value))
std::cout << "The value is: " << *p << std::endl;

return 0;
}

直接使用 std::get_if 函数获取对应值的指针,如果类型不匹配会返回空指针

std::visit函数

使用函数visit函数访问时,有点像使用std::sort这类函数,可以搭配自定义的结构(排序)重写operator(),让其变成可以被调用的函数对象,也可以定义lambda自带可执行特性。

自定义访问结构的写法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <variant>

int main()
{
std::variant<double, int> value = 119;

struct VisitPackage
{
auto operator()(const double& v) { std::cout << "The value is: " << v << std::endl; }
auto operator()(const int& v) { std::cout << "The value is: " << v << std::endl; }
};

std::visit(VisitPackage(), value);

return 0;
}

定义lambda函数组重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <iostream>
#include <variant>

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

int main()
{
std::variant<double, int> value = 119;

std::visit(overloaded {
[] (const double& v) { std::cout << "The value is: " << v << std::endl; },
[] (const int& v) { std::cout << "The value is: " << v << std::endl; }
}, value);

return 0;
}

这种方式将多个lambda放到一起形成重载,进而达到了访问variant数据的目的。

overloaded是什么

上文例子中的最后一个中使用到了 overloaded,这令人眼花缭乱的写法着实很诡异,不过我们可以从头来分析一下,最后两个例子中等价的两部分是

1
2
3
4
5
6
7
struct VisitPackage
{
auto operator()(const double& v) { std::cout << "The value is: " << v << std::endl; }
auto operator()(const int& v) { std::cout << "The value is: " << v << std::endl; }
};

VisitPackage()

1
2
3
4
5
6
7
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

overloaded {
[] (const double& v) { std::cout << "The value is: " << v << std::endl; },
[] (const int& v) { std::cout << "The value is: " << v << std::endl; }
}

要想理解它们为什么等价,我们首先的得弄清楚lambda表达式是什么,在剖析lambda之前先来看看 std::visit 函数需要的参数是什么,分析std::visit的参数,先看 struct VisitPackage 结构更容易一些。

std::visit的第一个参数

通俗的来说std::visit的第一个参数需要的是一个可执行的对象,如果对象能被执行就需要实现 operator() 这个操作符,看起来像函数一样,这就是为什么在 struct VisitPackage 中定义了 operator(),并且定义了两个形成了参数不同的静态重载,作用就是为了在访问 variant 对象时适配不同的类型,在访问variant 对象时会选择最匹配的 operator() 函数,进而实现了访问variant中不同类型值行为不同的目的。

那lambda表达式能实现这个目的吗?我们接着往下看

lambda 是什么

自从 C++11 引入lambda之后,对它赞美的声音不绝于耳,那lambda表达式究竟是怎样实现的呢?真的就是一个普通的函数吗?我们看一个小例子:

1
2
3
4
5
6
7
8
9
10
11
int main() {
int x = 5, y = 6;

auto func = [&](int n) {
return x + n;
};

func(7);

return 0;
}

这是一个使用lambda表达式简单的例子,代码中定义了一个int类型参数的返回值也是int的lambda函数,作用就是将外部变量x与函数参数的和返回,我们使用 cppinsights.io 网站来将此段代码展开

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
int main()
{
int x = 5;
int y = 6;

class __lambda_4_15
{
public:
inline /*constexpr */ int operator()(int n) const
{
return x + n;
}

private:
int & x;

public:
__lambda_4_15(int & _x)
: x{_x}
{}
};

__lambda_4_15 func = __lambda_4_15{x};
func.operator()(7);
return 0;
}

可以发现我们虽然定义了一个lambda函数,但是编译器为它生成了一个类 __lambda_4_15,生成了 int& 类型的构造函数,并实现了 operator操作符,再调用lambda函数时先生成了 __lambda_4_15类的对象,再调用类的 operator()函数 func.operator()(7);,看到这里是不是似曾相识,虽然还不是很明白,但是和struct VisitPackage的定义总是有种说不清道不明的血缘关系。

弄清楚了lambda函数的本质,现在要实现的是怎么把多个lambda函数合成一个对象,并且让他们形成重载,因为lambda函数本质上存在一个类,只需要定义一个子类,继承多个lambda表达式就可以了,其实 overloaded 这个模板类就是为了实现这个目的。

overloaded剖析

1
2
template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

一时间看起来很难理解,它来自 en.cppreference.com 中介绍 std::visit 访问 std::variant 的例子,可以换行看得更清楚一点:

1
2
3
4
5
6
// helper type for the visitor #4
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
// explicit deduction guide (not needed as of C++20)
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

template struct overloaded : Ts… { using Ts::operator()…; };

这是一个类模板的声明,模板的名字是overloaded

分步拆解来看:

template struct overloaded

表示类的模板参数为可变长的参数包 Ts
假设 Ts 包含 T1, T2, … , TN,那么这一句声明可以展开为:template struct overloaded

struct overloaded : Ts…

表示类的基类为参数包 Ts 内所有的参数类型
假设 Ts 包含 T1, T2, … , TN,那么这一句声明可以展开为:struct overloaded : T1, T2, …, TN

{ using Ts::operator()…; };

这是一个函数体内的变长 using 声明
假设 Ts 包含 T1, T2, … , TN,那么这一句声明可以展开为:{ using T1::operator(), T1::operator(), …, TN::operator(); }
经过这步声明,overloaded 类的参数包 Ts 内所有的参数作为基类的成员函数operator()均被 overloaded 类引入了自己的作用域

template overloaded(Ts…) -> overloaded;

这是一个自动推断向导说明,用于帮助编译器根据 overloaded 构造器参数的类型来推导 overloaded 的模板参数类型,C++17需要,C++20已不必写
它告诉编译器,如果 overloaded 构造器所有参数的类型的集合为Ts,那么 overloaded 的模板参数类型就是 Ts 所包含的所有类型
如果表达式a1, a2, …, an的类型分别为T1, T2, …, TN,那么构造器表达式overloaded x{a1, a2, …, an} 推导出,overloaded的类型就是 overloaded

经过这些解释,我们可以认为在最后一个例子中可能产生了类似这样的代码:

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
#include <iostream>
#include <variant>

class __lambda_12_7
{
public:
inline /*constexpr */ void operator()(const double & v) const
{
std::operator<<(std::cout, "The value is: ").operator<<(v).operator<<(std::endl);
}
};

class __lambda_13_7
{
public:
inline /*constexpr */ void operator()(const int & v) const
{
std::operator<<(std::cout, "The value is: ").operator<<(v).operator<<(std::endl);
}
};

template<>
struct overloaded<__lambda_12_7, __lambda_13_7> : public __lambda_12_7, public __lambda_13_7
{
using __lambda_12_7::operator();
// inline /*constexpr */ void ::operator()(const double & v) const;

using __lambda_13_7::operator();
// inline /*constexpr */ void ::operator()(const int & v) const;
};

int main()
{
std::variant<double, int> value = std::variant<double, int>(119);

std::visit(overloaded{__lambda_12_7(__lambda_12_7{}), __lambda_13_7(__lambda_13_7{})}, value);
return 0;
}

总结

  • std::variant 可以存储多个类型的值,并且它会自动处理类型转换和内存分配
  • std::variant 可以存储非 POD 类型和类对象,能够在运行时进行类型检查和转换,具有更高的类型安全性
  • 可以使用 std::visit 全局函数来访问 std::variant 中存储的值,该函数根据存储的值的类型自动选择调用哪个函数对象
  • 可以使用 std::holds_alternative 函数来检查变量中是否存储了特定的类型
  • 定义lambda函数时,编译器会为其生成一个类
==>> 反爬链接,请勿点击,原地爆炸,概不负责!<<==

代码是程序世界的运行规则,一个个字母的敲击正在规定着程序世界的运行秩序,无论代码写的天花乱坠,究其本质还是规定这一步要做什么,下一步继续做什么而已~

2023-6-23 21:13:04

Albert Shi wechat
欢迎您扫一扫上面的微信公众号,订阅我的博客