C++三剑客之std::variant(二)：深入剖析

相关系列文章

C++三剑客之std::optional(一) : 使用详解

C++三剑客之std::any(一) : 使用详解

C++之std::tuple(一) : 使用精讲(全)

C++三剑客之std::variant(一) : 使用

C++三剑客之std::variant(二)：深入剖析

目录

1.概述

2.辅助类介绍

2.1.std::negation

2.2.std::conjunction

2.3.std::is_destructible

2.4.std::is_object

2.5.is_default_constructible

2.6.std::is_trivially_destructible

2.7.std::in_place_type和std::in_place_index

3.原理分析

3.1.存储分析

3.2.构造函数

3.2.1.默认构造

3.2.2.使用单一值初始化

3.2.3.std::in_place_type

3.2.4.std::in_place_index

3.3.访问值

3.3.1.直接赋值

3.3.2.emplace

3.3.3.get

3.3.4.get_if

4.总结

C++三剑客之std::variant(一) : 使用-CSDN博客

前一篇关于std::variant的博客详细介绍了std::variant的使用和一些注意事项，熟悉和了解它的使用方法后，我们接着追根溯源，探索其本质，仔细阅读它的实现，分析一下源码。

1.概述

本文我们主要研究问题模板类std::variant如何做到存任意多个类型值的容器？不同类型怎么做到巧妙的构造与转换的?多种构造函数如何实现？内部数据怎么储存？为什么不能保存引用、数组和void类型？

std::variant是在头文件variant中，是C++17引入的，本文以VS2019平台展开讲解variant的原理和深层次用法。

2.辅助类介绍

2.1.std::negation

std::negation 逻辑非元函数，一元函数对象类，其调用将返回对其实参求反的结果(由一元操作符-返回)。如：

  1. #include 
  2. #include 
  3.  
  4. static_assert(
  5.     std::is_same<
  6.         std::bool_constant<false>,
  7.         typename std::negationtrue>>::type>::value,
  8.     "");
  9. static_assert(
  10.     std::is_same<
  11.         std::bool_constant<true>,
  12.         typename std::negationfalse>>::type>::value,
  13.     "");
  14.  
  15. int main()
  16. {
  17.     std::cout << std::negationtrue>>::value << '\n';  //输出：false
  18.     std::cout << std::negationfalse>>::value << '\n'; //输出：true
  19. }

std::bool_constant即是 true_type，取值为true，逻辑反则为false。std::bool_constant 即是false_type，取值为false，逻辑反则为true。

2.2.std::conjunction

std::conjunction 逻辑与元对象，在头文件type_traits中，一般用在判断可变参数是否满足某种条件上。示例如下：

  1. #include 
  2. #include 
  3.  
  4. // func is enabled if all Ts... have the same type as T
  5. template<typename T, typename... Ts>
  6. std::enable_if_t...>>
  7. func(T, Ts...) {
  8.     std::cout << "all types in pack are T\n";
  9. }
  10.  
  11. // otherwise
  12. template<typename T, typename... Ts>
  13. std::enable_if_t...>>
  14. func(T, Ts...) {
  15.     std::cout << "not all types in pack are T\n";
  16. }
  17.  
  18. int main() {
  19.     func(1, 2, 3);
  20.     func(1, 2, "hello!");
  21. }

输出：

  1. all types in pack are T
  2. not all types in pack are T

上述代码在func中用std::is_same判断模板函数的参数类型是否都是一样的，所有参数类型一样判定为true，否则为false；同样std::variant的源码也用到了这个，如：

  1. template <class... _Types>
  2. using _Variant_storage = _Variant_storage_...>, _Types...>;

std::conjunction就是判断可变参数对象是否都为简单销毁对象。

2.3.std::is_destructible

std::is_destructible 类型特征来检查一个类是否有可析构的类型。这有助于我们在编译时发现潜在的问题，例如试图删除非指针类型的对象。但它并不保证这个类型的析构函数是否真正做了正确的清理工作。因此，在定义类的析构函数时，我们需要仔细地考虑它是否真正释放了所有分配的资源。如下示例：

  1. #include 
  2. #include 
  3. #include 
  4.  
  5. class MyClass {
  6. public:
  7.   MyClass(int size) : arr(new int[size]), file("example.txt") {}
  8.   ~MyClass() { delete [] arr; }
  9.  
  10. private:
  11.   int* arr;
  12.   std::ofstream file;
  13. };
  14.  
  15. int main() {
  16.   std::cout << std::is_destructible::value << '\n'; //输出：true
  17.   std::cout << std::is_destructible<int>::value << '\n';     //输出: true
  18.   std::cout << std::is_destructible<int[]>::value << '\n';   //输出：false
  19.   std::cout << std::is_destructible::value << '\n'; //输出：true
  20. }

从上面的代码可以看出，我们定义的MyClass类具有可析构的类型。而int类型和std::ofstream类型也是可析构的。但是，int[]类型不是可析构的。这是因为数组类型不支持默认构造函数、拷贝构造函数或移动构造函数，从而导致不能正确地销毁。

2.4.std::is_object

std::is_object是一个用于元编程的C++类型特性，用于判断一个类型是否是对象类型，而不是类类型或枚举类型。这个在我之前的博客也讲的很清楚，如果还不是特别明白，可以再去翻翻博客C++之std::is_object-CSDN博客；在这里我就不多赘述了。

2.5.is_default_constructible

std::is_default_constructible模板，用于判断一个类型是否有默认构造函数。因为在某些情况下，需要在编译期间确定一个类型是否有默认构造函数。在使用该模板时需要包含头文件type_traits。示例代码：

  1. #include 
  2. #include 
  3.  
  4. class X {
  5. public:
  6.     X(int x): m_x(x) { }
  7. private:
  8.     int m_x;
  9. };
  10.  
  11. class Y {
  12. public:
  13.     Y() = default;
  14. private:
  15.     double m_y;
  16. };
  17.  
  18. int main() {
  19.     std::cout << std::is_default_constructible::value << '\n'; //输出：false
  20.     std::cout << std::is_default_constructible::value << '\n'; //输出：true
  21.     std::cout << std::is_default_constructible<int>::value << '\n'; //输出：true
  22.     std::cout << std::is_default_constructible<int[]>::value << '\n'; //输出：false
  23.     return 0;
  24. }

在上述示例代码中，我们定义了两个类X和Y，分别设置了构造函数和默认构造函数。然后分别使用is_default_constructible模板来判断是否有默认构造函数，最后还演示了一些基本类型和数组类型的情况。

2.6.std::is_trivially_destructible

判断一个类型T是否是一个平凡的可销毁类型（trivivally destructible）。主要用于检查这个类型的析构函数。一个trivivally destructible类（由class，struct/union）需要满足下面的条件：使用默认的析构函数、析构函数不能为虚的、它的基类和静态成员类型也必须是一个trivivally destructible类。如下示例：

  1. // is_trivially_destructible example
  2. #include 
  3. #include 
  4.  
  5. struct A { }; /* 符合trivivally destructible类型定义 */
  6. struct B { ~B(){} }; /* 没有使用隐式应答的析构函数, 即编译器合成的默认析构函数, 因此不是trivivally destructible类型 */
  7.  
  8. int main() {
  9.   std::cout << std::boolalpha; /* 将输出流bool解析为true/false, 而不是1/0 */
  10.   std::cout << "is_trivially_destructible:" << std::endl;
  11.   std::cout << "int: " << std::is_trivially_destructible<int>::value << std::endl; /* 基本类型是trivivally destructible类型 */
  12.   std::cout << "A: " << std::is_trivially_destructible::value << std::endl; /* A是trivivally destructible类型 */
  13.   std::cout << "B: " << std::is_trivially_destructible::value << std::endl; /* B不是trivivally destructible类型 */
  14.   return 0;
  15. }

输出：

  1. is_trivially_destructible:
  2. int: true
  3. A: true
  4. B: false

2.7.std::in_place_type和std::in_place_index

std::in_place_inde实际就是一个占位符，它的定义如下：

  1. template <size_t _Idx>
  2. inline constexpr in_place_index_t<_Idx> in_place_index{};

   in_place_index_t 定义如下：

  1. template <size_t>
  2. struct in_place_index_t { // tag that selects the index of a type to construct in place
  3.     explicit in_place_index_t() = default;
  4. };

从上面的代码可以看出 std::in_place_inde<_Idx> 是用来标识参数位置的数据类型，不过它是根据参数位置序号来判断的；同理也可以分析出std::in_place_type<_Ty>也是用来标识参数位置的数据类型，不过它是根据参数的类型来判断的，从std::in_place_type的定义可以看出来：

  1. struct in_place_t { // tag used to select a constructor which initializes a contained object in place
  2.     explicit in_place_t() = default;
  3. };
  4. inline constexpr in_place_t in_place{};
  5.  
  6. template <class>
  7. struct in_place_type_t { // tag that selects a type to construct in place
  8.     explicit in_place_type_t() = default;
  9. };
  10. template <class _Ty>
  11. inline constexpr in_place_type_t<_Ty> in_place_type{};

3.原理分析

3.1.存储分析

std::variant的内部用了union递归存储各种类型的数据，在头文件variant中按码索骥找到了存储std::variant的类_Variant_storage，内部定义了一个union：

  1. template <bool _TrivialDestruction, class... _Types>
  2. class _Variant_storage_ {}; // empty storage (empty "_Types" case)
  3.  
  4. // ALIAS TEMPLATE _Variant_storage
  5. template <class... _Types>
  6. using _Variant_storage = _Variant_storage_...>, _Types...>;
  7.  
  8. template <class _First, class... _Rest>
  9. class _Variant_storage_<true, _First, _Rest...> { // Storage for variant alternatives (trivially destructible case)
  10. public:
  11.     static constexpr size_t _Size = 1 + sizeof...(_Rest);
  12.     union {
  13.         remove_const_t<_First> _Head;
  14.         _Variant_storage<_Rest...> _Tail;
  15.     };
  16.  
  17.     _Variant_storage_() noexcept {} // no initialization (no active member)
  18.  
  19.     ...
  20. };

union自动按最大数据类型对齐的。std::variant的内存布局为：

第N个的_Tail为 _Variant_storage_ 或  _Variant_storage_，举个例子，如定义

std::variant y; 那么y的内存布局如下所示：

_Variant_storage_根据对象是否为"简单销毁对象"划分为：

_Variant_storage_ 和 _Variant_storage_，_Variant_storage_的实现为：

  1. template <class... _Types>
  2. using _Variant_storage = _Variant_storage_...>, _Types...>;
  3.  
  4. template <class _First, class... _Rest>
  5. class _Variant_storage_<true, _First, _Rest...> { // Storage for variant alternatives (trivially destructible case)
  6. public:
  7.     static constexpr size_t _Size = 1 + sizeof...(_Rest);
  8.     union {
  9.         remove_const_t<_First> _Head;
  10.         _Variant_storage<_Rest...> _Tail;
  11.     };
  12.  
  13.     _Variant_storage_() noexcept {} // no initialization (no active member)
  14.  
  15.     template <class... _Types>
  16.     constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
  17.         is_nothrow_constructible_v<_First, _Types...>)
  18.         : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
  19.  
  20.     template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
  21.     constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
  22.         is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
  23.         : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
  24.  
  25.     _NODISCARD constexpr _First& _Get() & noexcept {
  26.         return _Head;
  27.     }
  28.     _NODISCARD constexpr const _First& _Get() const& noexcept {
  29.         return _Head;
  30.     }
  31.     _NODISCARD constexpr _First&& _Get() && noexcept {
  32.         return _STD move(_Head);
  33.     }
  34.     _NODISCARD constexpr const _First&& _Get() const&& noexcept {
  35.         return _STD move(_Head);
  36.     }
  37. };

_Variant_storage_的实现为：

  1. template <class _First, class... _Rest>
  2. class _Variant_storage_<false, _First, _Rest...> { // Storage for variant alternatives (non-trivially destructible case)
  3. public:
  4.     static constexpr size_t _Size = 1 + sizeof...(_Rest);
  5.     union {
  6.         remove_const_t<_First> _Head;
  7.         _Variant_storage<_Rest...> _Tail;
  8.     };
  9.  
  10.     ~_Variant_storage_() noexcept { // explicitly non-trivial destructor (which would otherwise be defined as deleted
  11.                                     // since the class has a variant member with a non-trivial destructor)
  12.     }
  13.  
  14.     _Variant_storage_() noexcept {} // no initialization (no active member)
  15.  
  16.     template <class... _Types>
  17.     constexpr explicit _Variant_storage_(integral_constant<size_t, 0>, _Types&&... _Args) noexcept(
  18.         is_nothrow_constructible_v<_First, _Types...>)
  19.         : _Head(static_cast<_Types&&>(_Args)...) {} // initialize _Head with _Args...
  20.  
  21.     template <size_t _Idx, class... _Types, enable_if_t<(_Idx > 0), int> = 0>
  22.     constexpr explicit _Variant_storage_(integral_constant<size_t, _Idx>, _Types&&... _Args) noexcept(
  23.         is_nothrow_constructible_v<_Variant_storage<_Rest...>, integral_constant<size_t, _Idx - 1>, _Types...>)
  24.         : _Tail(integral_constant<size_t, _Idx - 1>{}, static_cast<_Types&&>(_Args)...) {} // initialize _Tail (recurse)
  25.  
  26.     _Variant_storage_(_Variant_storage_&&)      = default;
  27.     _Variant_storage_(const _Variant_storage_&) = default;
  28.     _Variant_storage_& operator=(_Variant_storage_&&) = default;
  29.     _Variant_storage_& operator=(const _Variant_storage_&) = default;
  30.  
  31.     _NODISCARD constexpr _First& _Get() & noexcept {
  32.         return _Head;
  33.     }
  34.     _NODISCARD constexpr const _First& _Get() const& noexcept {
  35.         return _Head;
  36.     }
  37.     _NODISCARD constexpr _First&& _Get() && noexcept {
  38.         return _STD move(_Head);
  39.     }
  40.     _NODISCARD constexpr const _First&& _Get() const&& noexcept {
  41.         return _STD move(_Head);
  42.     }
  43. };

_Variant_storage_类中提供了对外访问对象的接口 _Get()，包括左值引用和右值引用。由于上层的类_Variant_base是private继承_Variant_storage_的，从下面的代码可以看出：

  1. template <class... _Types>
  2. class _Variant_base
  3.     : private _Variant_storage<_Types...> { // Associate an integral discriminator with a _Variant_storage
  4. public:
  5.     using _Index_t                       = _Variant_index_t<sizeof...(_Types)>;
  6.     static constexpr auto _Invalid_index = static_cast<_Index_t>(-1);
  7.     _Index_t _Which;
  8.  
  9.     using _Storage_t = _Variant_storage<_Types...>;
  10.     _NODISCARD constexpr _Storage_t& _Storage() & noexcept { // access this variant's storage
  11.         return *this;
  12.     }
  13.     _NODISCARD constexpr const _Storage_t& _Storage() const& noexcept { // access this variant's storage
  14.         return *this;
  15.     }
  16.     _NODISCARD constexpr _Storage_t&& _Storage() && noexcept { // access this variant's storage
  17.         return _STD move(*this);
  18.     }
  19.     _NODISCARD constexpr const _Storage_t&& _Storage() const&& noexcept { // access this variant's storage
  20.         return _STD move(*this);
  21.     }
  22.  
  23.     _Variant_base() noexcept : _Storage_t{}, _Which{_Invalid_index} {} // initialize to the value-less state
  24.     ...
  25. };

由于上层的类不能访问_Variant_storage_的成员变量和函数，所以提供了专门的访问数据接口_Variant_raw_get，代码如下：

  1. template <size_t _Idx, class _Storage>
  2. _NODISCARD constexpr decltype(auto) _Variant_raw_get(
  3.     _Storage&& _Obj) noexcept { // access the _Idx-th element of a _Variant_storage
  4.     if constexpr (_Idx == 0) {
  5.         return static_cast<_Storage&&>(_Obj)._Get();
  6.     } else if constexpr (_Idx == 1) {
  7.         return static_cast<_Storage&&>(_Obj)._Tail._Get();
  8.     } else if constexpr (_Idx == 2) {
  9.         return static_cast<_Storage&&>(_Obj)._Tail._Tail._Get();
  10.     } else if constexpr (_Idx == 3) {
  11.         return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Get();
  12.     } else if constexpr (_Idx == 4) {
  13.         return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Get();
  14.     } else if constexpr (_Idx == 5) {
  15.         return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Get();
  16.     } else if constexpr (_Idx == 6) {
  17.         return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Get();
  18.     } else if constexpr (_Idx == 7) {
  19.         return static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Get();
  20.     } else if constexpr (_Idx < 16) {
  21.         return _Variant_raw_get<_Idx - 8>(
  22.             static_cast<_Storage&&>(_Obj)._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
  23.     } else if constexpr (_Idx < 32) {
  24.         return _Variant_raw_get<_Idx - 16>(
  25.             static_cast<_Storage&&>(_Obj)
  26.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
  27.     } else if constexpr (_Idx < 64) {
  28.         return _Variant_raw_get<_Idx - 32>(
  29.             static_cast<_Storage&&>(_Obj)
  30.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
  31.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
  32.     } else { // _Idx >= 64
  33.         return _Variant_raw_get<_Idx - 64>(
  34.             static_cast<_Storage&&>(_Obj)
  35.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
  36.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
  37.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail
  38.                 ._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail._Tail);
  39.     }
  40. }

函数中参数序号低于8的直接访问值，大于8的递归调用自身来访问值。

3.2.构造函数

3.2.1.默认构造

默认构造函数如下：

  1. template <class _First = _Meta_front, enable_if_t, int> = 0>
  2.     constexpr variant() noexcept(is_nothrow_default_constructible_v<_First>)
  3.         : _Mybase(in_place_index<0>) {} // value-initialize alternative 0

取出第一个参数_Meta_front，调用基类的构造函数，生成对象。象如下定义std::variant就会调用此构造函数：

std::variant<int, double, bool, float> y;

3.2.2.使用单一值初始化

  示例如下：

std::variant<bool, int, std::string> v(25);

如果这样编码，就会直接调用std::variant的单一赋值的构造函数，源码如下：

  1. template <class _Ty,
  2.         enable_if_t<sizeof...(_Types) != 0 //
  3.                         && !is_same_v<_Remove_cvref_t<_Ty>, variant> //
  4.                         && !_Is_specialization_v<_Remove_cvref_t<_Ty>, in_place_type_t> //
  5.                         && !_Is_in_place_index_specialization<_Remove_cvref_t<_Ty>> //
  6.                         && is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>, //
  7.             int> = 0>
  8. constexpr variant(_Ty&& _Obj) noexcept(is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>)
  9.         : _Mybase(in_place_index<_Variant_init_index<_Ty, _Types...>::value>, static_cast<_Ty&&>(_Obj)) {
  10.         // initialize to the type selected by passing _Obj to the overload set f(Types)...
  11.     }

通过_Variant_init_index找到_Ty在_Types...的位置，然后再调用_Variant_base的构造函数：

  1. template <size_t _Idx, class... _UTypes,
  2.         enable_if_t, _Idx>, _UTypes...>, int> = 0>
  3.     constexpr explicit _Variant_base(in_place_index_t<_Idx>, _UTypes&&... _Args) noexcept(
  4.         is_nothrow_constructible_v<_Meta_at_c, _Idx>, _UTypes...>)
  5.         : _Storage_t(integral_constant<size_t, _Idx>{}, static_cast<_UTypes&&>(_Args)...),
  6.           _Which{static_cast<_Index_t>(_Idx)} { // initialize alternative _Idx from _Args...
  7.     }

初始化_Which和_Variant_storage，如果有多个可能的类型匹配，可能导致歧义。

3.2.3.std::in_place_type

示例如下：

std::variant<int, double, std::string> v(std::in_place_type<double>, 34.66);

如果这样编码，就会直接调用std::variant的std::in_place_type构造函数，源码如下：

  1. template <class _Ty, class... _UTypes, class _Idx = _Meta_find_unique_index,
  2.         enable_if_t<_Idx::value != _Meta_npos && is_constructible_v<_Ty, _UTypes...>, int> = 0>
  3.     constexpr explicit variant(in_place_type_t<_Ty>, _UTypes&&... _Args) noexcept(
  4.         is_nothrow_constructible_v<_Ty, _UTypes...>) // strengthened
  5.         : _Mybase(in_place_index<_Idx::value>, static_cast<_UTypes&&>(_Args)...) {
  6.         // initialize alternative _Ty from _Args...
  7.     }

通过_Meta_find_unique_index找到_Ty在_Types...的位置，_Meta_find_unique_index循环递归查找_Ty的详细实现：

  1. template <class _List, class _Ty>
  2. struct _Meta_find_unique_index_ {
  3.     using type = integral_constant<size_t, _Meta_npos>;
  4. };
  5. template <class _List, class _Ty>
  6. using _Meta_find_unique_index =
  7.     // The index of _Ty in _List if it occurs exactly once, otherwise _Meta_npos
  8.     typename _Meta_find_unique_index_<_List, _Ty>::type;
  9.  
  10. constexpr size_t _Meta_find_unique_index_i_2(const bool* const _Ptr, const size_t _Count,
  11.     const size_t
  12.         _First) { // return _First if there is no _First < j < _Count such that _Ptr[j] is true, otherwise _Meta_npos
  13.     return _First != _Meta_npos && _Meta_find_index_i_(_Ptr, _Count, _First + 1) == _Meta_npos ? _First : _Meta_npos;
  14. }
  15.  
  16. constexpr size_t _Meta_find_unique_index_i_(const bool* const _Ptr,
  17.     const size_t _Count) { // Pass the smallest i such that _Ptr[i] is true to _Meta_find_unique_index_i_2
  18.     return _Meta_find_unique_index_i_2(_Ptr, _Count, _Meta_find_index_i_(_Ptr, _Count));
  19. }
  20.  
  21. template <template <class...> class _List, class _First, class... _Rest, class _Ty>
  22. struct _Meta_find_unique_index_<_List<_First, _Rest...>, _Ty> {
  23.     using type = integral_constant<size_t,
  24.         _Meta_find_unique_index_i_(_Meta_find_index_<_List<_First, _Rest...>, _Ty>::_Bools, 1 + sizeof...(_Rest))>;
  25. };

最后调用_Variant_base的构造函数，生成_Variant_storage，存储数据。

3.2.4.std::in_place_index

示例如下：

std::variant<bool, std::string> v(std::in_place_index<1>, "14256435");

如果这样编码，就会直接调用std::variant的std::in_place_index构造函数，源码如下：

  1. template <size_t _Idx, class... _UTypes,
  2.         enable_if_t, _UTypes...>, int> = 0>
  3.     constexpr explicit variant(in_place_index_t<_Idx>, _UTypes&&... _Args) noexcept(
  4.         is_nothrow_constructible_v<_Meta_at_c, _UTypes...>) // strengthened
  5.         : _Mybase(in_place_index<_Idx>, static_cast<_UTypes&&>(_Args)...) {
  6.         // initialize alternative _Idx from _Args...
  7.     }

直接调用_Variant_base的构造函数，这种生成std::vaiant流程会简单一些，也比较好理解一些。

3.3.访问值

3.3.1.直接赋值

如：

  1. std::variant<bool, int，std::string> v;
  2. v = "hello world";

如果这样编码，就会直接调用std::variant的operator=，源码如下：

  1. // assignment [variant.assign]
  2.     template <class _Ty, enable_if_t, variant> //
  3.                                          && is_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty> //
  4.                                          && is_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>, //
  5.                              int> = 0>
  6.     variant& operator=(_Ty&& _Obj) noexcept(is_nothrow_assignable_v<_Variant_init_type<_Ty, _Types...>&, _Ty>&&
  7.             is_nothrow_constructible_v<_Variant_init_type<_Ty, _Types...>, _Ty>) {
  8.         // assign/emplace the alternative chosen by overload resolution of _Obj with f(_Types)...
  9.         constexpr size_t _TargetIdx = _Variant_init_index<_Ty, _Types...>::value;
  10.         if (index() == _TargetIdx) {
  11.             auto& _Target = _Variant_raw_get<_TargetIdx>(_Storage());
  12.             _Target       = static_cast<_Ty&&>(_Obj);
  13.         } else {
  14.             using _TargetTy = _Variant_init_type<_Ty, _Types...>;
  15.             if constexpr (_Variant_should_directly_construct_v<_TargetTy, _Ty>) {
  16.                 this->_Reset();
  17.                 _Emplace_valueless<_TargetIdx>(static_cast<_Ty&&>(_Obj));
  18.             } else {
  19.                 _TargetTy _Temp(static_cast<_Ty&&>(_Obj));
  20.                 this->_Reset();
  21.                 _Emplace_valueless<_TargetIdx>(_STD move(_Temp));
  22.             }
  23.         }
  24.  
  25.         return *this;
  26.     }

它的流程如下：

关键步骤：1）比较当前的index()和_TargetIdx是否相同，相同，直接赋值。

2）不相同，这需要析构原来的对象，重新构造新的对象，赋值等操作，流程会比较复杂一些，这些实现是在_Emplace_valueless里面，代码如下：

  1. template <size_t _Idx, class... _ArgTypes>
  2.     _Meta_at_c& _Emplace_valueless(_ArgTypes&&... _Args) noexcept(
  3.         is_nothrow_constructible_v<_Meta_at_c, _ArgTypes...>) {
  4.         // initialize alternative _Idx from _Args...
  5.         // pre: valueless_by_exception()
  6.         auto& _Obj = _Variant_raw_get<_Idx>(_Storage());
  7.         _Construct_in_place(_Obj, static_cast<_ArgTypes&&>(_Args)...);
  8.         this->_Set_index(_Idx);
  9.         return _Obj;
  10.     }

3.3.2.emplace

从emplace的源代码

  1. template <class _Ty, class... _ArgTypes, size_t _Idx = _Meta_find_unique_index::value,
  2.         enable_if_t<_Idx != _Meta_npos && is_constructible_v<_Ty, _ArgTypes...>, int> = 0>
  3.     _Ty& emplace(_ArgTypes&&... _Args) noexcept(is_nothrow_constructible_v<_Ty, _ArgTypes...>) /* strengthened */ {
  4.         // emplace alternative _Ty from _Args...
  5.         this->_Reset();
  6.         return _Emplace_valueless<_Idx>(static_cast<_ArgTypes&&>(_Args)...);
  7.     }

可以看出跟3.3.1的流程差不多，这里就不多赘述了。

3.3.3.get

1) 通过序号 index 来get值

  1. template <size_t _Idx, class... _Types>
  2. _NODISCARD constexpr decltype(auto) get(
  3.     variant<_Types...>& _Var) { // access the contained value of _Var if its _Idx-th alternative is active
  4.     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
  5.     if (_Var.index() == _Idx) {
  6.         return _Variant_raw_get<_Idx>(_Var._Storage());
  7.     }
  8.  
  9.     _Throw_bad_variant_access();
  10. }

 通过当前的index()和_Idx比对，来获取std::variant的值，_Variant_raw_get函数在3.1章节讲过；

如果当前的index()不是_Idx，这会抛出异常。

2）通过 类型_Ty 来get值

  1. template <class _Ty, class... _Types>
  2. _NODISCARD constexpr decltype(auto) get(
  3.     variant<_Types...>& _Var) { // access the contained value of _Var if its alternative _Ty is active
  4.     constexpr size_t _Idx = _Meta_find_unique_index, _Ty>::value;
  5.     static_assert(_Idx < sizeof...(_Types),
  6.         "get(variant&) requires T to occur exactly once in Types. (N4835 [variant.get]/5)");
  7.     return _STD get<_Idx>(_Var);
  8. }

通过_Meta_find_unique_index获取到类型_Ty的_Idx, 然后调用序号index版本的get来获取值。

3.3.4.get_if

get_if也是有两种，通过序号index和类型_Ty来获取值，从源码的

  1. template <size_t _Idx, class... _Types>
  2. _NODISCARD constexpr auto get_if(
  3.     variant<_Types...>* _Ptr) noexcept { // get the address of *_Ptr's contained value if it holds alternative _Idx
  4.     static_assert(_Idx < sizeof...(_Types), "variant index out of bounds");
  5.     return _Ptr && _Ptr->index() == _Idx ? _STD addressof(_Variant_raw_get<_Idx>(_Ptr->_Storage())) : nullptr;
  6. }

和

  1. template <class _Ty, class... _Types>
  2. _NODISCARD constexpr add_pointer_t<_Ty> get_if(
  3.     variant<_Types...>* _Ptr) noexcept { // get the address of *_Ptr's contained value if it holds alternative _Ty
  4.     constexpr size_t _Idx = _Meta_find_unique_index, _Ty>::value;
  5.     static_assert(_Idx != _Meta_npos,
  6.         "get_if(variant *) requires T to occur exactly once in Types. (N4835 [variant.get]/9)");
  7.     return _STD get_if<_Idx>(_Ptr);
  8. }

可以看到，基本上可以3.3.3的get原理差不多，在这里就不多赘述了。

4.总结

到此我们已经全部分析完毕，细节也谈及了，喜欢的给个赞并收藏，谢谢。

注：本文转载自blog.csdn.net的流星雨爱编程的文章"https://blog.csdn.net/haokan123456789/article/details/135534042"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！