std::variant 源码分析
背景：
c++17 里边有个std::variant 它的用法挺神奇的,类似c 语言中的union ，本文将从源码角度，看下支撑它的到底是什么
std::variant 用法
| C++
#include
#include
#include
#include
int main()
{
std::variant v, w;
v = 42; // v contains int
int i = std::get(v);
assert(42 == i); // succeeds
w = std::get(v);
w = std::get<0>(v); // same effect as the previous line
w = v; // same effect as the previous line
// std::get(v); // error: no double in [int, float]
// std::get<3>(v); // error: valid index values are 0 and 1
try {
std::get(w); // w contains int, not float: will throw
}
catch (const std::bad_variant_access& ex) {
std::cout << ex.what() << '\n';
}
using namespace std::literals;
std::variant x("abc");
// converting constructors work when unambiguous
x = "def"; // converting assignment also works when unambiguous
std::variant y("abc");
// casts to void const * when passed a char const *
assert(std::holds_alternative(y)); // succeeds
y = "xyz"s;
assert(std::holds_alternative(y)); // succeeds
} |
Output:
| C++
std::get: wrong index for variant |
std::variant 源码分析
| C++
template
class _LIBCPP_TEMPLATE_VIS variant;
template
class _LIBCPP_TEMPLATE_VIS variant
: private __sfinae_ctor_base<
__all...>::value,
__all...>::value>,
private __sfinae_assign_base<
__all<(is_copy_constructible_v<_Types> &&
is_copy_assignable_v<_Types>)...>::value,
__all<(is_move_constructible_v<_Types> &&
is_move_assignable_v<_Types>)...>::value>
{
......
private:
__variant_detail::__impl<_Types...> __impl;
} |
这个里边源码极其复杂，这里我们只分析重点， 可以看出来variant内部有个private的成员， __impl,也就搞清楚impl的结构，就搞清楚了整个variant的底层支撑原理
__impl
| C++
template
class _LIBCPP_TEMPLATE_VIS __impl
: public __copy_assignment<__traits<_Types...>> {
using __base_type = __copy_assignment<__traits<_Types...>>;
{
.....
}; |
接下来看下__copy_assignment的定义
__copy_assignment
| C++
template
class _LIBCPP_TEMPLATE_VIS __copy_assignment;
template \
class _LIBCPP_TEMPLATE_VIS __copy_assignment<__traits<_Types...>, \
copy_assignable_trait> \
: public __move_assignment<__traits<_Types...>> { \
using __base_type = __move_assignment<__traits<_Types...>>; \
\
public: \
using __base_type::__base_type; \
using __base_type::operator=; \
\
__copy_assignment(const __copy_assignment&) = default; \
__copy_assignment(__copy_assignment&&) = default; \
~__copy_assignment() = default; \
copy_assignment \
__copy_assignment& operator=(__copy_assignment&&) = default; \
} |
__copy_assignment 又继承了__move_assignment
__move_assignment
| C++
template
class _LIBCPP_TEMPLATE_VIS __move_assignment;
template \
class _LIBCPP_TEMPLATE_VIS __move_assignment<__traits<_Types...>, \
move_assignable_trait> \
: public __assignment<__traits<_Types...>> { \
using __base_type = __assignment<__traits<_Types...>>; \
\
public: \
using __base_type::__base_type; \
using __base_type::operator=; \
\
__move_assignment(const __move_assignment&) = default; \
__move_assignment(__move_assignment&&) = default; \
~__move_assignment() = default; \
__move_assignment& operator=(const __move_assignment&) = default; \
move_assignment \
} |
__move_assignment 又继承了__assignment
__assignment
| C++
template
class _LIBCPP_TEMPLATE_VIS __assignment : public __copy_constructor<_Traits> {
using __base_type = __copy_constructor<_Traits>;
public:
using __base_type::__base_type;
using __base_type::operator=;
template _Ip, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
auto& __emplace(_Args&&... __args) {
this->__destroy();
auto& __res = this->__construct_alt(__access::__base::__get_alt<_Ip>(*this),
_VSTD::forward<_Args>(__args)...);
this->__index = _Ip;
return __res;
}
.......
} |
__assignment 又继承了__copy_constructor
__copy_constructor
| C++
emplate
class _LIBCPP_TEMPLATE_VIS __copy_constructor;
template \
class _LIBCPP_TEMPLATE_VIS __copy_constructor<__traits<_Types...>, \
copy_constructible_trait> \
: public __move_constructor<__traits<_Types...>> { \
using __base_type = __move_constructor<__traits<_Types...>>; \
\
public: \
using __base_type::__base_type; \
using __base_type::operator=;
.......
} |
__copy_constructor 又继承了__move_constructor
__move_constructor
| C++
template
class _LIBCPP_TEMPLATE_VIS __move_constructor;
template \
class _LIBCPP_TEMPLATE_VIS __move_constructor<__traits<_Types...>, \
move_constructible_trait> \
: public __constructor<__traits<_Types...>> { \
using __base_type = __constructor<__traits<_Types...>>; \
\
public: \
using __base_type::__base_type; \
using __base_type::operator=; \
\
__move_constructor(const __move_constructor&) = default; \
move_constructor \
~__move_constructor() = default; \
__move_constructor& operator=(const __move_constructor&) = default; \
__move_constructor& operator=(__move_constructor&&) = default; \
} |
__move_constructor 又继承了__constructor
__constructor
| C++
template
class _LIBCPP_TEMPLATE_VIS __constructor : public __destructor<_Traits> {
using __base_type = __destructor<_Traits>;
public:
using __base_type::__base_type;
using __base_type::operator=;
protected:
template _Ip, class _Tp, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
static _Tp& __construct_alt(__alt<_Ip, _Tp>& __a, _Args&&... __args) {
::new ((void*)_VSTD::addressof(__a))
__alt<_Ip, _Tp>(in_place, _VSTD::forward<_Args>(__args)...);
return __a.__value;
}
....
} |
__constructor 又继承了__destructor
__destructor
| C++
template
class _LIBCPP_TEMPLATE_VIS __destructor;
template \
class _LIBCPP_TEMPLATE_VIS __destructor<__traits<_Types...>, \
destructible_trait> \
: public __base { \
using __base_type = __base; \
using __index_t = typename __base_type::__index_t; \
\
public: \
using __base_type::__base_type; \
using __base_type::operator=; \
\
__destructor(const __destructor&) = default; \
__destructor(__destructor&&) = default; \
destructor \
__destructor& operator=(const __destructor&) = default; \
__destructor& operator=(__destructor&&) = default; \
\
protected: \
........
\
} |
__destructor 又继承了__base, 这个__base 是核心关键
__base
| C++
template <_Trait _DestructibleTrait, class... _Types>
class _LIBCPP_TEMPLATE_VIS __base {
public:
using __index_t = __variant_index_t;
inline _LIBCPP_INLINE_VISIBILITY
explicit constexpr __base(__valueless_t tag) noexcept
: __data(tag), __index(__variant_npos<__index_t>) {}
template _Ip, class... _Args>
inline _LIBCPP_INLINE_VISIBILITY
explicit constexpr __base(in_place_index_t<_Ip>, _Args&&... __args)
:
__data(in_place_index<_Ip>, _VSTD::forward<_Args>(__args)...),
__index(_Ip) {}
inline _LIBCPP_INLINE_VISIBILITY
constexpr bool valueless_by_exception() const noexcept {
return index() == variant_npos;
}
inline _LIBCPP_INLINE_VISIBILITY
constexpr size_t index() const noexcept {
return __index == __variant_npos<__index_t> ? variant_npos : __index;
}
protected:
inline _LIBCPP_INLINE_VISIBILITY
static constexpr size_t __size() { return sizeof...(_Types); }
__union<_DestructibleTrait, 0, _Types...> __data;
__index_t __index;
friend struct __access::__base;
friend struct __visitation::__base;
}; |
跟了这么久，看了__base 数据结构定义的核心的是
| C++
__union<_DestructibleTrait, 0, _Types...> __data;
__index_t __index;
|
也就是定义了__index,和一个__union，接下来搞清楚这2个，就大概知道其原理了
__index_t
| C++
using __index_t = __variant_index_t;
template _NumAlts>
using __variant_index_t = unsigned int; |
可以理解成 __index_t 就是int， __index_t __index就是 int __index_t
__union
| C++
template <_Trait _DestructibleTrait, size_t _Index, class... _Types>
union _LIBCPP_TEMPLATE_VIS __union;
template <_Trait _DestructibleTrait, size_t _Index>
union _LIBCPP_TEMPLATE_VIS __union<_DestructibleTrait, _Index> {};
template _Index, class _Tp, class... _Types> \
union _LIBCPP_TEMPLATE_VIS __union _Index, \
_Tp, \
_Types...> { \
public: \
........ \
\
private: \
char __dummy; \
__alt<_Index, _Tp> __head; \
__union __tail; \
\
friend struct __access::__union; \
} |
看的出来__union 底层结构就是union共用体， 而整个结构tuple很相似，就是通过组合方式，拆解可变参数集，利用泛化，版本中指递归，很是巧妙，
总结：
经过上边对variant分析看的出来，内部逻辑十分复杂，最底层支撑的数据就是union，也就是说更高级点。
std::variant 是如何获取取值
我们在用法可以看到std::get<0>(v); 或者std::get(v);是等价的，都可以获取值，我也很好奇，这里边到底是怎么实现的，接下来我们看下源码是怎么实现的,
std::get
| C++
template
inline
constexpr _Tp& get(variant<_Types...>& __v) {
return _VSTD::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
} |
可以看的出来，_Tp是int
__find_exactly_one_t
| C++
template
struct __find_exactly_one_t
: public __find_detail::__find_exactly_one_checked<_T1, _Args...> {
};
template
struct __find_exactly_one_checked {
static constexpr bool __matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...};
static constexpr size_t value = __find_detail::__find_idx(0, __matches);
static_assert(value != __not_found, "type not found in type list" );
static_assert(value != __ambiguous, "type occurs more than once in type list");
}; |
上边源码看到__find_exactly_one_t<_Tp, _Types...>::value 是找到你要get类型，在union的位置，然好调用std::get<0>(v),也就是你根据类型获取值，最终转化成了根据序号获取值
__matches[sizeof...(_Args)] = {is_same<_T1, _Args>::value...}; 是解包操作，存储了共用体的类型与你要的类型相比匹配的值
__find_idx 找到__matches里边为true的值，它的index就是对应的序号
std::get<0>
| C++
template _Ip, class... _Types>
inline _LIBCPP_INLINE_VISIBILITY
_LIBCPP_AVAILABILITY_THROW_BAD_VARIANT_ACCESS
constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(
variant<_Types...>& __v) {
return __generic_get<_Ip>(__v);
} |
这个要比上边定义复杂一些，这里我们就不具体跟源码，variant_alternative_t<_Ip, variant<_Types...>>拿到的是，0号元素对应类型，
__generic_get
| C++
template _Ip, class _Vp>
inline _LIBCPP_INLINE_VISIBILITY
constexpr auto&& __generic_get(_Vp&& __v) {
using __variant_detail::__access::__variant;
if (!__holds_alternative<_Ip>(__v)) {
__throw_bad_variant_access();
}
return __variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value;
}
template _Ip, class... _Types>
inline _LIBCPP_INLINE_VISIBILITY
constexpr bool __holds_alternative(const variant<_Types...>& __v) noexcept {
return __v.index() == _Ip;
} |
__holds_alternative<_Ip>(__v) 用于判断当前取的类型，跟variant初始化的时候类型是否一致，如果不一致会抛异常，这也就解释了用法中
| C++
try {
std::get(w); // w contains int, not float: will throw
}
catch (const std::bad_variant_access& ex) {
std::cout << ex.what() << '\n';
} |
会抛异常的根本原因
__get_alt
| C++
struct __variant {
template _Ip, class _Vp>
inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto&& __get_alt(_Vp&& __v) {
return __base::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v).__impl);
}
};
struct __base {
template _Ip, class _Vp>
inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto&& __get_alt(_Vp&& __v) {
return __union::__get_alt(_VSTD::forward<_Vp>(__v).__data,
in_place_index<_Ip>);
}
};
struct __union {
template
inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<0>) {
return _VSTD::forward<_Vp>(__v).__head;
}
template _Ip>
inline _LIBCPP_INLINE_VISIBILITY
static constexpr auto&& __get_alt(_Vp&& __v, in_place_index_t<_Ip>) {
return __get_alt(_VSTD::forward<_Vp>(__v).__tail, in_place_index<_Ip - 1>);
}
}; |
经过上边一层一层的着最终到了struct __union 这个结构挺有意思的， 它也是递归解包，直到匹配到了__get_alt 的上边一个版本， 然后返回__head,
总结
通过分析源码可以看出来__variant::__get_alt<_Ip>(_VSTD::forward<_Vp>(__v)).__value 这个最终返回了std::variant里边底层结构union对应位置的值，很是不好分析，希望对读者有所帮助