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

前言

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

preview 原理

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

std::variant<int,double>

请添加图片描述
解释一下:重点是**_Variadic_union**, 它是一个递归union,大概相当于c中的:

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

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

std::variant的实现重点:存储

通过上面的preview,相信读者已经通过直观的认识快速入门并理解了底层是如何存储数据的了。
下面我们用GDB把数据打印出来看看:

variant<int,double> v1(3);

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

v1 = 2.0;

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

 348   template<typename... _Types>349     union _Variadic_union { };350351   template<typename _First, typename... _Rest>352     union _Variadic_union<_First, _Rest...>353     {354       constexpr _Variadic_union() : _M_rest() { }355356       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     { }360361       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     { }365366       _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哪?当然,大家已经看到它对应每层的数据,不过它的实际类型是**_Uninitialized**,在我们的例子中分别对应只包含int或double的结构体,
在这里插入图片描述
不要简单的以为总是“类型 _M_storage”, 看下不是int、double等简单类型而是一个结构体或类会怎么样?

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;231232   template<typename _Type>233     struct _Uninitialized<_Type, true>234     {235       template<typename... _Args>236     constexpr237     _Uninitialized(in_place_index_t<0>, _Args&&... __args)238     : _M_storage(std::forward<_Args>(__args)...)239     { }240241       constexpr const _Type& _M_get() const & noexcept242       { return _M_storage; }243244       constexpr _Type& _M_get() & noexcept245       { return _M_storage; }246247       constexpr const _Type&& _M_get() const && noexcept248       { return std::move(_M_storage); }249250       constexpr _Type&& _M_get() && noexcept251       { return std::move(_M_storage); }252253       _Type _M_storage;254     };255256   template<typename _Type>257     struct _Uninitialized<_Type, false>258     {259       template<typename... _Args>260     constexpr261     _Uninitialized(in_place_index_t<0>, _Args&&... __args)262     {263       ::new ((void*)std::addressof(_M_storage))264         _Type(std::forward<_Args>(__args)...);265     }266267       const _Type& _M_get() const & noexcept268       { return *_M_storage._M_ptr(); }269270       _Type& _M_get() & noexcept271       { return *_M_storage._M_ptr(); }272273       const _Type&& _M_get() const && noexcept274       { return std::move(*_M_storage._M_ptr()); }275276       _Type&& _M_get() && noexcept277       { return std::move(*_M_storage._M_ptr()); }278279       __gnu_cxx::__aligned_membuf<_Type> _M_storage;280     };

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

这里是引用

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)  //获得第一个数据类型的值  我们的例子中是int284     __get(in_place_index_t<0>, _Union&& __u) noexcept285     { return std::forward<_Union>(__u)._M_first._M_get(); }286287   template<size_t _Np, typename _Union>288     constexpr decltype(auto)  //获得第N个数据类型的值  我们的例子中第二个是double289     __get(in_place_index_t<_Np>, _Union&& __u) noexcept290     {291       return __variant::__get(in_place_index<_Np-1>,  //递归292                   std::forward<_Union>(__u)._M_rest);293     }294295   // Returns the typed storage for __v.296   template<size_t _Np, typename _Variant>297     constexpr decltype(auto)298     __get(_Variant&& __v) noexcept299     {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");

std::variant的实现重点:赋值

赋值大体有三种办法:

  1. 初始化(调用构造函数)
  2. 重新赋值 (调用operator = )
  3. 重新赋值 (调用emplace)
    但赋值很复杂,因为情况很多:
  4. variant alternatives都是int般简单类型,=右边也是简单类型
  5. variant alternatives都是trivial类,=右边也是trivial类
  6. variant alternatives都是非trivial类,=右边也是非trivial类
  7. variant alternatives都是非trivial类,=右边是构造非trivial类的参数
  8. variant alternatives都是非trivial类,而且有些类的ctor或mtor或assignment operator被删除
  9. copy assignment/ move assignment 会抛异常导致valueless

  10. 情况多的不厌其烦。头大。
    我们只挑最简单的说下(捏个软柿子~), 考虑如下代码:
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;426427     std::__do_visit<void>([](auto&& __this_mem) mutable428       {429         std::_Destroy(std::__addressof(__this_mem));430       }, __variant_cast<_Types...>(*this));431432     _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.mzph.cn/news/694937.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

SQL注入:堆叠注入-强网杯[随便注]

目录 什么是堆叠注入&#xff1f; 强网杯-随便注 rename && alter绕过 prepare绕过 Handle绕过 靶机&#xff1a;BUUCTF在线评测 什么是堆叠注入&#xff1f; 在一些场景中&#xff0c;应用程序支持一次执行多条SQL语句&#xff0c;我们称为堆叠查询&#xff0c;…

MyBatis-Plus:通用分页实体封装

分页查询实体&#xff1a;PageQuery package com.example.demo.demos.model.query;import com.baomidou.mybatisplus.core.metadata.OrderItem; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import lombok.Data; import org.springframework.util.St…

MYSQL数据库详解

一、数据库的基本概念 数据&#xff08;data&#xff09;&#xff1a;指对客观事物进行描述并可以鉴别的符号。这些符号是可识别的&#xff0c;抽象的。 比如数字、图片、音频等。 数据库管理系统&#xff08;DBMS&#xff09;&#xff1a;数据库极其管理它的软件组成。 数据库…

机器人内部传感器阅读笔记及心得-位置传感器-电位器式位置传感器

位置传感器 位置感觉是机器人最基本的感觉要求&#xff0c;可以通过多种传感器来实现。位置传感器包括位置和角度检测传感器。常用的机器人位置传感器有电位器式、光电式、电感式、电容式、霍尔元件式、磁栅式及机械式位置传感器等。机器人各关节和连杆的运动定位精度要求、重…

qt-OPENGL-星系仿真

qt-OPENGL-星系仿真 一、演示效果二、核心程序三、下载链接 一、演示效果 二、核心程序 #include "model.h"Model::Model(QOpenGLWidget *_glWidget) { glWidget _glWidget;glWidget->makeCurrent();initializeOpenGLFunctions(); }Model::~Model() {destroyV…

【Pytorch深度学习开发实践学习】B站刘二大人课程笔记整理lecture04反向传播

lecture04反向传播 课程网址 Pytorch深度学习实践 部分课件内容&#xff1a; import torchx_data [1.0,2.0,3.0] y_data [2.0,4.0,6.0] w torch.tensor([1.0]) w.requires_grad Truedef forward(x):return x*wdef loss(x,y):y_pred forward(x)return (y_pred-y)**2…

浅谈WPF之利用RichTextBox实现富文本编辑器

在实际应用中&#xff0c;富文本随处可见&#xff0c;如留言板&#xff0c;聊天软件&#xff0c;文档编辑&#xff0c;特定格式内容等&#xff0c;在WPF开发中&#xff0c;如何实现富文本编辑呢&#xff1f;本文以一个简单的小例子&#xff0c;简述如何通过RichTextBox实现富文…

Zabbix 6.2.1 安装

目录 1、监控介绍 监控的重要性 网站的可用性 监控范畴 如何监控 2、Zabbix 介绍 zabbix 简介 zabbix 主要功能 zabbix 监控范畴 Zabbix 监控组件 zabbix 常见进程 zabbix agentd 工作模式 zabbix 环境监控中概念 3、搭建LNMP 拓扑规划 安装MySQL 安装 Nginx …

【智能家居】7、主程序编写+实现语音、网络和串口功能

需要毕业论文私信有偿获取 截止目前mainPro.c代码 #include <stdio.h> #include <string.h>#include "controlDevices.h" #include "inputCmd.h"struct Devices *findDevicesName(char *name,struct Devices *phead){struct Devices *tmp=ph…

2012及其以上系统修改服务器密码指南

修改服务器密码指南,目前介绍两种不同的方案 方法一 指令式 winR键 弹出运行框里输入 cmd 点击确认或者右下角开始程序里面的点开运行 2.在弹出框里手动输入以下一组文字&#xff1a;net user administrator 123456 框内无法粘贴 需要手动输入 其中administrator 是用…

贝叶斯统计——入门级笔记

绪论 1.1 引言 全概率公式 贝叶斯公式 三种信息 总体信息 当把样本视为随机变量时&#xff0c;它有概率分布&#xff0c;称为总体分布&#xff0e; 如果我们已经知道总体的分布形式这就给了我们一种信息&#xff0c;称为总体信息 样本信息 从总体中抽取的样本所提供的信息 先…

【PX4学习笔记】13.飞行安全与炸机处理

目录 文章目录 目录使用QGC地面站的安全设置、安全绳安全参数在具体参数中的体现安全绳 无人机炸机处理A&#xff1a;无人机异常时控操作B&#xff1a;无人机炸机现场处理C&#xff1a;无人机炸机后期维护和数据处理D&#xff1a;无人机再次正常飞行测试 无人机飞行法律宣传 使…

22. 【Linux教程】Linux 结束进程

前面小节介绍了如何启动一个程序进程&#xff0c;还介绍了如何查看系统进程信息&#xff0c;本小节来介绍如何通过 kill 命令结束进程。 1. Linux 进程信号介绍 下面列举出 Linux 进程信号的描述&#xff1a; 信号名称描述1HUP挂起2INT中断3QUIT结束运行9KILL无条件终止11SEG…

STM32CubeIDE开发(二), 全面解析cubeMX图形配置工具

STM32CubeIDE开发(二&#xff09;&#xff0c; 全面解析cubeMX图形配置工具 已于 2023-03-15 10:31:13 修改1374 收藏 29 分类专栏&#xff1a; ​编辑STM32CubeIDE开发实践案例专栏收录该内容 36 篇文章43 订阅 订阅专栏 目录 一、cubeIDE 集成cubeMX 二、STM32CubeMX…

Python format函数

在Python编程中&#xff0c;format()函数是一个非常重要且常用的字符串格式化方法&#xff0c;用于将各种数据类型插入到字符串中&#xff0c;并指定其格式。这个函数可以动态地生成各种格式的字符串&#xff0c;包括文本、数字、日期等。本文将深入探讨Python中的format()函数…

【Vuforia+Unity】AR04-地面、桌面平面识别功能

不论你是否曾有过相关经验&#xff0c;只要跟随本文的步骤&#xff0c;你就可以成功地创建你自己的AR应用。 官方教程Ground Plane in Unity | Vuforia Library 这个功能很棒&#xff0c;但是要求也很不友好&#xff0c;只能支持部分移动设备&#xff0c;具体清单如下&#xf…

Socket通信---Python发送数据给C++程序

0. Problems 很多时候实现某种功能&#xff0c;需要在不同进程间发送数据&#xff0c;目前有几种主流的方法&#xff0c;如 让python和C/C程序互相发送数据&#xff0c;其实有几种方法&#xff1a; 共享内存共享文件Socket通信 在这里只提供Socket通信的例程&#xff0c;共享…

挑战30天学完Python:Day16 日期时间

&#x1f4d8; Day 16 &#x1f389; 本系列为Python基础学习&#xff0c;原稿来源于 30-Days-Of-Python 英文项目&#xff0c;大奇主要是对其本地化翻译、逐条验证和补充&#xff0c;想通过30天完成正儿八经的系统化实践。此系列适合零基础同学&#xff0c;或仅了解Python一点…

奇异递归模板模式应用5-静态多态

动态多态&#xff1a;C动态多态是利用虚函数特性实现的&#xff0c;即基类指针(引用&#xff09;指向派生类指针(引用)。由于虚函数的实现是在运行期进行的&#xff0c;因而会产生运行期开销&#xff08;虚表指针偏移&#xff0c;与分支预测器和CPU指令流水线相关&#xff09;。…

【关于深度学习的一些资料】

曾梦想执剑走天涯&#xff0c;我是程序猿【AK】 目录 动手学深度学习Awesome Deep LearningTensorFlow Official ModelsPyTorch Image ModelsDeep Reinforcement LearningNeural Style Transfer 动手学深度学习 动手学深度学习 https://zh.d2l.ai/chapter_installation/index.…