Modern C++ std::variant的实现原理

已于 2024-02-23 07:49:03 修改
阅读量3.6k 收藏 18
点赞数 32
分类专栏： modern C++ 文章标签： c++ modern C++ variant variant原理
于 2024-02-22 07:32:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaiminlove/article/details/136211123
版权

1. 前言

std::variant是C++17标准库引入的一种类型，用于安全地存储和访问多种类型中的一种。它类似于C语言中的联合体（union），但功能更为强大。与联合体相比，std::variant具有类型安全性，可以判断当前存储的实际类型，并且可以存储结构体/类等复杂的数据结构。

2. preview 原理

我们依然采用“一图胜千言”的思想，给大家先展现下std::variant对应的UML图。这些图都是用我之前写的工具DotObject自动画出来的，有兴趣请参考《GDB调试技巧实战–自动化画出类关系图》，还有一篇应用实践《Modern C++利用工具快速理解std::tuple的实现原理》。
我们先举个简单的例子, 看下variant的庐山真面目。

std::variant<int,double>

请添加图片描述

3. std::variant的实现重点：存储

通过上面的preview，相信读者已经通过直观的认识快速入门并理解了底层是如何存储数据的了。
解释一下：
（1）重点是_Variadic_union, 它是一个递归union，大概相当于c中的：

union _Variadic_union{
	数据  _M_first; //第N层的
	_Variadic_union  _M_rest;  //下一层还是一个union
}

（2） 另一个重点是：_Variant_storage::_M_index 是当前数据类型是可选类型列表中第几个，比如设置一个0.2，则当前类型是double, 此时_M_index=1(从0开始）。

下面我们用GDB把数据打印出来看看：

variant<int,double> v1(3);

请添加图片描述
再赋值为2.0

v1 = 2.0;

在这里插入图片描述
在有了直观认识后，我们来看下源代码：

 348   template<typename... _Types>
 349     union _Variadic_union { };
 350
 351   template<typename _First, typename... _Rest>
 352     union _Variadic_union<_First, _Rest...>
 353     {
 354       constexpr _Variadic_union() : _M_rest() { }
 355
 356       template<typename... _Args>
 357     constexpr _Variadic_union(in_place_index_t<0>, _Args&&... __args)
 358     : _M_first(in_place_index<0>, std::forward<_Args>(__args)...)
 359     { }
 360
 361       template<size_t _Np, typename... _Args>
 362     constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&... __args)
 363     : _M_rest(in_place_index<_Np-1>, std::forward<_Args>(__args)...)
 364     { }
 365
 366       _Uninitialized<_First> _M_first;
 367       _Variadic_union<_Rest...> _M_rest;
 368     };

先不必管行356到364(问题一，这几行干啥用？），367行体现了递归的思想（递归在标准库实现中大量使用），每次都把第一个值单独拿出来。如果理解有困难，直接扔到cppinsights让它帮我们展开（为了方便cppinsights展开，我把_M_first先简化为_First类型了，之后再详细分析它）：
在这里插入图片描述
可以看到
_Variadic_union<int,double> = int _M_first + _Variadic_union _M_rest
_Variadic_union = double _M_first + _Variadic_union<>
OK, _M_rest是为了递归，那 _M_first 哪？当然，大家已经看到它对应每层的数据（int/double），不过它的实际类型是 _Uninitialized，在我们的例子中分别对应只包含int或double的结构体,
在这里插入图片描述
不要简单的以为_Uninitialized总是“类型 _M_storage”, 看下存结构体或类会怎么样？

class Person{
    public:
        Person(const string& name, int age):_name(name),_age(age){}
        ~Person(){
            cout<<"Decons Person:";
            print();
        }
        void print(){
            cout<<"name="<<_name<<" age="<<_age<<endl;
        }
    private:
        string _name;
        int _age;
};
int main(){
  variant<int,Person> v2;
}

请添加图片描述
可见它把Person变成了char[40], 40恰为Person的size大小。
让我们看下**_Uninitialized**的定义：

 227   // _Uninitialized<T> is guaranteed to be a trivially destructible type,
 228   // even if T is not.
 229   template<typename _Type, bool = std::is_trivially_destructible_v<_Type>>
 230     struct _Uninitialized;
 231
 232   template<typename _Type>
 233     struct _Uninitialized<_Type, true>
 234     {
 235       template<typename... _Args>
 236     constexpr
 237     _Uninitialized(in_place_index_t<0>, _Args&&... __args)
 238     : _M_storage(std::forward<_Args>(__args)...)
 239     { }
 240
 241       constexpr const _Type& _M_get() const & noexcept
 242       { return _M_storage; }
 243
 244       constexpr _Type& _M_get() & noexcept
 245       { return _M_storage; }
 246
 247       constexpr const _Type&& _M_get() const && noexcept
 248       { return std::move(_M_storage); }
 249
 250       constexpr _Type&& _M_get() && noexcept
 251       { return std::move(_M_storage); }
 252
 253       _Type _M_storage;
 254     };
 255
 256   template<typename _Type>
 257     struct _Uninitialized<_Type, false>
 258     {
 259       template<typename... _Args>
 260     constexpr
 261     _Uninitialized(in_place_index_t<0>, _Args&&... __args)
 262     {
 263       ::new ((void*)std::addressof(_M_storage))
 264         _Type(std::forward<_Args>(__args)...);
 265     }
 266
 267       const _Type& _M_get() const & noexcept
 268       { return *_M_storage._M_ptr(); }
 269
 270       _Type& _M_get() & noexcept
 271       { return *_M_storage._M_ptr(); }
 272
 273       const _Type&& _M_get() const && noexcept
 274       { return std::move(*_M_storage._M_ptr()); }
 275
 276       _Type&& _M_get() && noexcept
 277       { return std::move(*_M_storage._M_ptr()); }
 278
 279       __gnu_cxx::__aligned_membuf<_Type> _M_storage;
 280     };

很明显，针对is_trivially_destructible_v是true、false各有一个特化，type为Person时命中_Uninitialized<_Type, false>（因为它有自己定义的析构函数，故is_trivially_destructible_v==false, 细节请参考下面的截图）

这里是引用

4. std::variant的实现重点：get(获取值)

存是递归，取也是递归取
给出任意一个variant object, 比如v1, 我们知道

  1. 数据类型对应的下标是v1._M_index
  2. 数据存在v1._M_u
    则要想获得第一个数据类型的值只需return v1._M_u._M_first
    要想获得第二个数据类型的值只需return v1._M_u._M_rest._M_first
    要想获得第三个数据类型的值只需return v1._M_u._M_rest._M_rest._M_first
    … …
    这正是源代码的实现方式：
282   template<typename _Union>
 283     constexpr decltype(auto)  //获得第一个数据类型的值  我们的例子中是int
 284     __get(in_place_index_t<0>, _Union&& __u) noexcept
 285     { return std::forward<_Union>(__u)._M_first._M_get(); }
 286
 287   template<size_t _Np, typename _Union>
 288     constexpr decltype(auto)  //获得第N个数据类型的值  我们的例子中第二个是double
 289     __get(in_place_index_t<_Np>, _Union&& __u) noexcept
 290     {
 291       return __variant::__get(in_place_index<_Np-1>,  //递归
 292                   std::forward<_Union>(__u)._M_rest);
 293     }
 294
 295   // Returns the typed storage for __v.
 296   template<size_t _Np, typename _Variant>
 297     constexpr decltype(auto)
 298     __get(_Variant&& __v) noexcept
 299     {
 300       return __variant::__get(std::in_place_index<_Np>,
 301                   std::forward<_Variant>(__v)._M_u);
 302     }

对照上面的实现想一想下面的代码如何运行的？

variant<int,double> v(1.0);
cout<<get<1>(v);

这个哪？

std::variant<int, double, char, string> myVariant("mzhai");
string s = get<3>(myVariant);

需要很多次._M_rest对不？ 所以如果你非常看重效率，那么请把常用的类型安排在前面，比如把上面的代码改成:

std::variant<string, int, double, char> myVariant("mzhai");

后来注释，这是debug的情况，开启优化后没有性能问题。 请参考 《Modern C++ std::variant 我小看了get的速度》。

5. std::variant的实现重点：赋值

赋值大体有三种办法：

  1. 初始化（调用构造函数）
  2. 重新赋值 (调用operator = )
  3. 重新赋值 (调用emplace)

但赋值很复杂，因为情况很多：

  1. variant alternatives都是int般简单类型，=右边也是简单类型
  2. variant alternatives都是trivial类，=右边也是trivial类
  3. variant alternatives都是非trivial类，=右边也是非trivial类
  4. variant alternatives都是非trivial类，=右边是构造非trivial类的参数
  5. variant alternatives都是非trivial类，而且有些类的ctor或mtor或assignment operator被删除
  6. copy assignment/ move assignment 会抛异常导致valueless
  7. …
    情况多的不厌其烦。头大。
    我们只挑最简单的说下(捏个软柿子~), 考虑如下代码：
std::variant<int, double> v;
v = 2.0f;

对应的实现为：

1456       template<typename _Tp>
1457     enable_if_t<__exactly_once<__accepted_type<_Tp&&>>
1458             && is_constructible_v<__accepted_type<_Tp&&>, _Tp>
1459             && is_assignable_v<__accepted_type<_Tp&&>&, _Tp>,
1460             variant&>
1461     operator=(_Tp&& __rhs)
1462     noexcept(is_nothrow_assignable_v<__accepted_type<_Tp&&>&, _Tp>
1463          && is_nothrow_constructible_v<__accepted_type<_Tp&&>, _Tp>)
1464     {
1465       constexpr auto __index = __accepted_index<_Tp>;
1466       if (index() == __index)   
			//index()为0，因为初始化v时以int初始化，__index为1
			//这种情况对应的是前面那次赋值和这次赋值类型一样。比如v=1.0; v=2.0
1467         std::get<__index>(*this) = std::forward<_Tp>(__rhs);
1468       else
1469         {//前后两次赋值类型不一样，比如v=1; v=2.0.  本例v=2.0f走这里。
1470           using _Tj = __accepted_type<_Tp&&>;
1471           if constexpr (is_nothrow_constructible_v<_Tj, _Tp>
1472                 || !is_nothrow_move_constructible_v<_Tj>)
1473         this->emplace<__index>(std::forward<_Tp>(__rhs));//本例走这
1474           else
1475         operator=(variant(std::forward<_Tp>(__rhs)));
1476         }
1477       return *this;
1478     }

1499       template<size_t _Np, typename... _Args>
1500     enable_if_t<is_constructible_v<variant_alternative_t<_Np, variant>,
1501                        _Args...>,
1502             variant_alternative_t<_Np, variant>&>
1503     emplace(_Args&&... __args)
1504     {
1505       static_assert(_Np < sizeof...(_Types),
1506             "The index must be in [0, number of alternatives)");
1507       using type = variant_alternative_t<_Np, variant>;
1508       namespace __variant = std::__detail::__variant;
1509       // Provide the strong exception-safety guarantee when possible,
1510       // to avoid becoming valueless.
1511       if constexpr (is_nothrow_constructible_v<type, _Args...>)
1512         {
1513           this->_M_reset();  //析构原对象，并置_M_index=-1
1514           __variant::__construct_by_index<_Np>(*this, //placement new,构造新值
1515           std::forward<_Args>(__args)...);
1516         }
1517       else if constexpr (is_scalar_v<type>)
1518         {
1519           // This might invoke a potentially-throwing conversion operator:
1520           const type __tmp(std::forward<_Args>(__args)...);
1521           // But these steps won't throw:
1522           this->_M_reset();
1523           __variant::__construct_by_index<_Np>(*this, __tmp);
1524         }
1525       else if constexpr (__variant::_Never_valueless_alt<type>()
1526           && _Traits::_S_move_assign)

析构原来的类型对象和构造新的类型对象请分别参考_M_reset __construct_by_index

 422       void _M_reset()
 423       {
 424     if (!_M_valid()) [[unlikely]]
 425       return;
 426
 427     std::__do_visit<void>([](auto&& __this_mem) mutable
 428       {
 429         std::_Destroy(std::__addressof(__this_mem));
 430       }, __variant_cast<_Types...>(*this));
 431
 432     _M_index = static_cast<__index_type>(variant_npos);
 433       }

1092   template<size_t _Np, typename _Variant, typename... _Args>
1093     inline void
1094     __construct_by_index(_Variant& __v, _Args&&... __args)
1095     {
1096       auto&& __storage = __detail::__variant::__get<_Np>(__v);
1097       ::new ((void*)std::addressof(__storage))
1098         remove_reference_t<decltype(__storage)>
1099       (std::forward<_Args>(__args)...);
1100       // Construction didn't throw, so can set the new index now:
1101       __v._M_index = _Np;
1102     }

赋值原理基本大体如此，如有读者感觉意犹未尽，这里我给一个程序供大家调试研究思考：

#include<iostream>
#include<variant>
using namespace std;


int main(){
    class C1{
        public:
            C1(int i):_i(i){}
        private:
            int _i;
    };

    cout<<is_nothrow_constructible_v<C1><<endl;
    cout<<is_nothrow_move_constructible_v<C1><<endl;

    variant<string, C1> v;
    v = 10; //重点在这里

    return 0;
}

提示：

  1. 没走emplace, 走了1475 operator=(variant(std::forward<_Tp>(__rhs)));
  2. 还记得上面我们留了一个问题吗？

先不必管行356到364(问题一，这几行干啥用？）

本例调用了362的构造函数 constexpr _Variadic_union(in_place_index_t<_Np>, _Args&&… __args)
这个构造函数就是为类类型(有parameterized constructor)准备的。

深山老宅
关注
  • 32
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Modern C++ std::unique_ptr的实现原理
老宅的虚拟空间
01-28 245
modern C++ std::unique_ptr的实现原理
Modern C++ std::weak_ptr的实现原理
老宅的虚拟空间
01-27 767
weak_ptr实现原理
C++ 可变体(variant)
weixin_45925735的博客
03-22 4789
那么给他ItCat这个用户自定义类型加一个默认构造器，那么在可变体在初始化过程中，就能从类型参数列表<ItCat,int, float>中的第一个ItCat获得一个默认构造器。下面的代码是声明一个可变体的用法，在variant关键字的尖括号内，依次指定可变体的的数据类型。传递给，std::visit回调的函数，而这回调函数就是所谓的“访问者”，以实现一些非常复杂的业务逻辑。的C++编译器来说，无疑是给它增加困扰，而C++编译器对待这种模棱两可的值，它默认匹配值的数据类型是。的情况下，会得到一个编译器错误。
C++编程新技能！std::variant详解，掌握多类型值存储！
Lion_Long的博客
03-23 4096
C++标准库中的std::variant是C++17引入的一种数据类型，它的作用是可以同时存储多种不同类型的值，但在任意时间只能有一种类型的值被存储。这使得std::variant成为一种灵活的数据类型，适用于需要处理多种可能类型的情况。std::variant的优势在于它提供了类型安全和便利的接口，相比传统的联合体（union），std::variant不需要手动管理数据成员的活跃性，也提供了更加友好和安全的访问方法。它在处理多样化数据类型、泛型编程以及处理变化的数据结构时非常有用。
C++(24): C++17探索：std::variant的使用
最新发布
tecsai的博客
05-21 520
std::variant是C++标准库中的一个模板类，它允许我们在一种类型安全的方式下存储多种类型的值。它的行为类似于C语言中的联合体（union），但提供了更多的类型安全性和功能。与C语言的联合体不同，std::variant跟踪其当前持有的类型，并确保在使用时不会出现未定义的行为。
C++17之std::variant
热门推荐
janeqi1987的专栏
09-05 3万+
从C中采用的c++提供了对union的支持，union是能够保存可能类型列表之一的对象。但是，这种语言特性也有一些缺点: 对象不知道它们当前持有的值的类型。 由于这个原因，您不能有non-trivial的成员，比如std::string(从c++ 11起, union原则上可以有non-trivial的成员，但是必须实现特殊的成员函数，比如复制构造函数和析构函数，因为只有通过代码逻辑才...
C++访问std::variant类型数据的几种方式
AlbertS Home of Technology
06-23 3544
`std::variant`（可变体） 是 `C++17` 中引入的一个新的类模板，提供了一种存储不同类型的值的方式，类似于之前版本中的 `union`（联合体），但可以存储非 `POD` 类型和类对象，能够在运行时进行类型检查和转换，但具有更多的功能和更高的类型安全性，今天来看一下存储在`std::variant`中的数据要怎么读取...
C++语法糖(std::variant)详解以及示例代码
weixin_43862733的博客
10-17 297
在上面的程序中，我们使用了一个 std::variant 对象 value 来存储整型、浮点型和字符串类型中的任意一种。在程序中，我们分别将 value 赋值为整型、浮点型和字符串类型，并使用 std::get 来获取对应的值。在之前的版本中，C++ 可以使用 union 来存储不同类型的数据，但是 union 存在一些限制，比如不能存储非 POD 类型和类对象。std::variant 是 C++17 中引入的一个新类模板，它可以存储一组类型中的任意一个，并且能够在运行时进行类型检查和转换。
c++ 17 ' std::variant ' for c++ 11/14/17
01-27
MPark.VariantC++17 std::variant for C++11/14/17IntroductionMPark.Variant is an implementation of C++17 std::variant for C++11/14/17.Based on Continuously tested against libc++'s std::variant test ...
common_type:std 的实现
06-01
在`common_type-master`这个压缩包文件中，可能包含了一个实现`std::common_type`功能的开源库，或者是一系列相关的示例代码，用于深入理解其工作原理和使用方法。通过研究这些代码，我们可以更深入地了解`std::...
Variant.zip_c++变体实现_variant cpp
07-14
C++ 变体类实现类及资料包含source code
variant:Variant 是一个变化的 C++11 类，它尽可能地克隆 javascript 行为
06-07
标题提到的"variant:Variant 是一个变化的 C++11 类"可能是指某个库或自定义实现，尝试在C++11标准下模拟这种行为。 `variant`的主要作用是处理异构数据，即在不同的时间点，同一变量可以持有不同类型的数据。这在...
effective modern c++
11-02
1. **智能指针**：C++11引入了智能指针（如`std::unique_ptr`、`std::shared_ptr`和`std::weak_ptr`），以替代原始指针，自动管理对象生命周期，避免内存泄漏。理解它们的工作原理和应用场景至关重要。 2. **RAII...
C++17类型std::variant介绍
fangfanglovezhou的博客
10-25 2243
C++17类型std::variant介绍。
C++ 实现Variant类
WSG的博客--盛年不重来,一日难再晨.及时当勉励,岁月不待人.
07-22 3411
Variant类借鉴于Qt的QVariant类，类似于Boost的any类。它把常用类型使用一个类包装起来，这样使用QVector等容器时，其内部就可以存储不同的数据。例如： std::vector<Variant> vec; vec.push_back(1); // 整形 vec.push_back("str"); // 字符串 vec.push_back(f...
【C++】std::variant 用法
爱学习的卡比兽
06-13 347
【代码】【C++】std::variant 用法。
C++ std::variant 总结
PX1525813502的博客
04-26 930
return 0;输出如下:1010.3Aborted写入浮点数后再访问整数类型成员, 直接抛出了异常, 这提供了一个类型安全的保证。除此之外, 它能自动维护C++ 当中的复杂类型,也就是构造和析构函数的调用。return 0;1010.3。
C++三剑客之std::variant(一) : 使用
红军不怕远征难，万水千山只等闲
12-28 3404
可以对 t 赋初值，对于基本类型，它是0、false还是nullptr。//输出: 3// ERROR以上都是我日常工作中对std::variant的用法的总结；做技术，要知其然，更要知其所以然，后面我将从std::varant的源码实现上继续分析它的原理，敬请期待。。。
c++ std::variant用法
Ken的博客
11-21 314
在 C++17 之前，为了改进这些问题，提出了std::variant。
std::get std::variant
02-22
std::get是C++标准库中的一个函数模板，用于从std::variant对象中获取指定类型的值。std::variant是C++17引入的一个模板类，它可以存储多个不同类型的值，但在任意给定时间只能存储其中的一个值。 使用std::get函数时，需要提供一个std::variant对象和一个索引，该索引表示要获取的值在std::variant中的位置。如果std::variant中存储的是指定类型的值，则std::get函数返回该值的引用；否则，将抛出std::bad_variant_access异常。 以下是std::get和std::variant的示例代码： ```cpp #include <iostream> #include <variant> int main() { std::variant<int, double, std::string> var; var = 42; int intValue = std::get<int>(var); std::cout << "Int value: " << intValue << std::endl; var = 3.14; double doubleValue = std::get<double>(var); std::cout << "Double value: " << doubleValue << std::endl; var = "Hello"; try { int invalidValue = std::get<int>(var); std::cout << "Int value: " << invalidValue << std::endl; } catch (const std::bad_variant_access& e) { std::cout << "Exception caught: " << e.what() << std::endl; } return 0; } ``` 输出结果： ``` Int value: 42 Double value: 3.14 Exception caught: bad_variant_access ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

深山老宅

鸡蛋不错的话，要不要激励下母鸡

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值