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

news2024/11/24 16:11:08

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)准备的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1465569.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

kali xrdp

kali xrdp

Kali Linux 使用远程桌面连接——xrdp&xfce_kali xfce桌面-CSDN博客 Ubuntu/Debian/Kali xrdp远程桌面黑屏/空屏/无画面解决办法 - 知乎 (zhihu.com) sudo apt-get install xrdp -y sudo apt-get install xfce4 -ysudo systemctl enable xrdp --now systemctl status xrd…
阅读更多...
PowerDesigner：pdm文件与sql文件互相转，数据库类型切换

PowerDesigner：pdm文件与sql文件互相转，数据库类型切换

PowerDesigner 依据sql文件生成pdm file——reverse engineer—— database 依据pdm文件导出sql 选中——database——generate database 切换库类型
阅读更多...
利用nginx内部访问特性实现静态资源授权访问

利用nginx内部访问特性实现静态资源授权访问

在nginx中&#xff0c;将静态资源设为internal&#xff1b;然后将前端的静态资源地址改为指向后端&#xff0c;在后端的响应头部中写上静态资源地址。 近期客户对我们项目做安全性测评&#xff0c;暴露出一些安全性问题&#xff0c;其中一个是有些静态页面&#xff08;*.html&…
阅读更多...
Flink中的双流Join

Flink中的双流Join

1. Flink中双流Join介绍 Flink版本Join支持类型Join API1.4innerTable/SQL1.5inner,left,right,fullTable/SQL1.6inner,left,right,fullTable/SQL/DataStream Join大体分为两种&#xff1a;Window Join 和 Interval Join 两种。 Window Join又可以根据Window的类型细分为3种…
阅读更多...
nginx服务基础用法（概念、安装、热升级）

nginx服务基础用法（概念、安装、热升级）

目录 一、I/O模型概述 1、I/O概念 1.1 计算机的I/O 1.2 Linux的I/O 2、零拷贝技术 3、同步/异步&#xff08;消息反馈机制&#xff09; 4、阻塞/非阻塞 5、网络I/O模型 5.1 阻塞型 I/O 模型&#xff08;blocking IO&#xff09; 5.2 非阻塞型 I/O 模型 (nonblocking …
阅读更多...
使用代理IP技术实现爬虫同步获取和保存

使用代理IP技术实现爬虫同步获取和保存

概述 在网络爬虫中&#xff0c;使用代理IP技术可以有效地提高爬取数据的效率和稳定性。本文将介绍如何在爬虫中同步获取和保存数据&#xff0c;并结合代理IP技术&#xff0c;以提高爬取效率。 正文 代理IP技术是一种常用的网络爬虫技术&#xff0c;通过代理服务器转发请求&a…
阅读更多...
Google发布开放的模型Gemma

Google发布开放的模型Gemma

今天&#xff0c;Google 发布了一系列最新的开放式大型语言模型 —— Gemma&#xff01;Google 正在加强其对开源人工智能的支持&#xff0c;我们也非常有幸能够帮助全力支持这次发布&#xff0c;并与 Hugging Face 生态完美集成。 Gemma 提供两种规模的模型&#xff1a; 7B …
阅读更多...
使用向量数据库pinecone构建应用05：人脸相似度查询Facial Similarity Search

使用向量数据库pinecone构建应用05：人脸相似度查询Facial Similarity Search

Building Applications with Vector Databases 下面是这门课的学习笔记&#xff1a;https://www.deeplearning.ai/short-courses/building-applications-vector-databases/ Learn to create six exciting applications of vector databases and implement them using Pinecon…
阅读更多...
深入探索Linux：ACL权限、特殊位与隐藏属性的奥秘

深入探索Linux：ACL权限、特殊位与隐藏属性的奥秘

前言&#xff1a; 在Linux系统中&#xff0c;文件和目录的权限管理是一项至关重要的任务。它决定了哪些用户或用户组可以对文件或目录执行读、写或执行等操作。传统的Linux权限模型基于用户、组和其他的概念&#xff0c;但随着时间的推移&#xff0c;这种模型在某些情况下显得…
阅读更多...
SQL库操作

SQL库操作

1、创建数据库 概念 创建数据库&#xff1a;根据项目需求创建一个存储数据的仓库 使用create database 数据库名字创建 数据库层面可以指定字符集:charset/character set 数据库层面可以指定校对集:collate 创建数据库会在磁盘指定存放处产生一个文件夹 创建语法 create …
阅读更多...
springmvc+mybatis+springboot航空飞机订票售票系统_f48cp

springmvc+mybatis+springboot航空飞机订票售票系统_f48cp

互联网发展的越来越快了&#xff0c;在当下社会节点&#xff0c;人们也开始越来越依赖互联网。通过互联网信息和数据&#xff0c;极大地满足用户要求[5]。飞机订票系统使用了B/S模式&#xff0c;并且不需要安装第三方插件&#xff0c;他们甚至能直接在电脑上随机随地实现飞机订…
阅读更多...
Go 中的 init 如何用？它的常见应用场景有哪些呢？

Go 中的 init 如何用？它的常见应用场景有哪些呢？

嗨&#xff0c;大家好&#xff01;我是波罗学。本文是系列文章 Go 技巧第十六篇&#xff0c;系列文章查看&#xff1a;Go 语言技巧。 Go 中有一个特别的 init() 函数&#xff0c;它主要用于包的初始化。init() 函数在包被引入后会被自动执行。如果在 main 包中&#xff0c;它也…
阅读更多...
JavaGuide-SQL在mysql中的执行过程

JavaGuide-SQL在mysql中的执行过程

SQL在mysql中的执行过程 原文连接 SQL在mysql中的执行过程 基础架构概览 我们先总结基本组件 连接器: 身份认证 权限相关的,我们连接的时候会验证查询缓存: 8.0之后移除,执行查询的时候,会先查缓存分析器: 分析你的sql语句,包括词法分析 语法分析优化器: 按照mysql认为最…
阅读更多...
LED智能互联办公室照明恒流调光IC芯片无频闪H5114

LED智能互联办公室照明恒流调光IC芯片无频闪H5114

调光高辉度65536级/高精度3% LED降压型恒流驱动器H5114 产品描述 H5114是一款外围电路简单的多功能平 均电流型LED恒流驱动器&#xff0c;适用于5-90V电压范围的非隔离式大功率恒流LED驱动领域。 芯片采用了平均电流模式控制&#xff0c;输出电流精度在3&#xff05;&#xff…
阅读更多...
http相关概念以及apache的功能（最详细讲解！！！！）

http相关概念以及apache的功能（最详细讲解！！！！）

概念 互联网&#xff1a;是网络的网络&#xff0c;是所有类型网络的母集 因特网&#xff1a;世界上最大的互联网网络 万维网&#xff1a;www &#xff08;不是网络&#xff0c;而是数据库&#xff09;是网页与网页之间的跳转关系 URL:万维网使用统一资源定位符&#xff0c;…
阅读更多...
GEE入门篇|遥感专业术语（实践操作1）：搜索及查看图像集合信息

GEE入门篇|遥感专业术语（实践操作1）：搜索及查看图像集合信息

Earth Engine 的搜索栏可用于查找影像和定位重要内容有关 Earth Engine 中数据集的信息&#xff0c;让我们使用位于搜索栏上方的Earth Engine代码&#xff0c;用于查找有关 Landsat 7 集合 2 的信息原始场景。首先&#xff0c;在搜索栏中输入“Landsat 7 collection 2”&#x…
阅读更多...
【Power Apps】实现一个简单的可编辑列表

【Power Apps】实现一个简单的可编辑列表

简单来说&#xff0c;我们这次是要实现一个可以直接在列表上增加、修改、删除数据的功能。 大概就像这样。 之前我们都是拿列表做一个数据展示的功能&#xff0c;真要增加、修改、删除数据是在另一张表单上做的&#xff0c;我们这回要去掉另一个表单&#xff0c;直接在列表上做…
阅读更多...
RabbitMQ学习整理————基于RabbitMQ实现RPC

RabbitMQ学习整理————基于RabbitMQ实现RPC

基于RabbitMQ实现RPC 前言什么是RPCRabbitMQ如何实现RPCRPC简单示例通过Spring AMQP实现RPC 前言 这边参考了RabbitMQ的官网&#xff0c;想整理一篇关于RabbitMQ实现RPC调用的博客&#xff0c;打算把两种实现RPC调用的都整理一下&#xff0c;一个是使用官方提供的一个Java cli…
阅读更多...
适用于生物行业的样本管理系统

适用于生物行业的样本管理系统

在生物样本管理系统的应用中&#xff0c;我们首先需要了解生物样本的特点和要求。生物样本具有多样性和易变性&#xff0c;需要被妥善保存和跟踪&#xff0c;以确保其质量和可用性。 因此&#xff0c;一个有效的生物样本管理系统需要具备以下特点&#xff1a; 全面性&#xff1…
阅读更多...
测试用例设计方法：招式组合，因果判定出世

测试用例设计方法：招式组合，因果判定出世

1 引言 上篇讲了等价类划分和边界值分析法&#xff0c;而这两种方法只考虑了单个的输入条件&#xff0c;并未考虑输入条件的各种组合、输入条件之间的相互制约关系的场景。基于此短板&#xff0c;因果图法和判定表法应运而生。 2 因果图法 2.1 概念及原理 2.1.1 定义 一种…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023