C++中variant以及visit实现原理

2023-03-28 10:51 2023-03-28 10:55 作者: xmh0511

````cpp
#include <iostream>
#include <string>
#include <utility>
#include <array>
template<std::size_t N>
struct Indice{};
template<class... Args>
union Storage{};
template<class First, class... Rest>
union Storage<First, Rest...>{
    template<std::size_t N, class U>
    Storage(U u, Indice<N>):Storage(u,Indice<N-1>{}){

}
    template<class U>
    Storage(U u,Indice<0>):ele(u){

}
    First ele;
    Storage<Rest...> rest;
};
template<class ...T>
struct Variant{
    template<std::size_t N, class U>
    Variant(U u, Indice<N> i):storage(u,i),Index(N){}
    Storage<T...> storage;
    std::size_t Index;
};
template<class ... T, std::size_t N>
auto get_index_element(Storage<T...> v, Indice<N>){
   static_assert(sizeof...(T) > N);
   return get_index_element(v.rest,Indice<N-1>{});
}
template<class ... T>
auto get_index_element(Storage<T...> v, Indice<0>){
    return v.ele;
}
template<std::size_t N,class F, class V>
auto dispatch(F f, V v){
    return f(get_index_element(v,Indice<N>{}));
}
template<class F, class S, std::size_t ...N>
auto convert_to_array(std::index_sequence<N...>){
    using type = decltype(dispatch<0,F,S>);
    return std::array<type*,sizeof...(N)>{ dispatch<N,F,S>... };
}
template<class F, class ...T>
auto convert_to_array(){
   return convert_to_array<F,Storage<T...>>(std::make_index_sequence<sizeof...(T)>());
}
template<class F, class ...T>
auto visit(F f, Variant<T...> v){
    auto arr = convert_to_array<F,T...>();
    return arr[v.Index](f,v.storage);
}
int main() {
    auto c = Variant<int, char>{1,Indice<0>{}};
    visit([](auto v){
        std::cout<< typeid(v).name();
    },c);
}
````
visit的主体思想是通过模板函数的模板参数记录`std::size_t`类型的常量，为每个层级的元素的存储生成一个访问函数，该函数最终的函数类型就是一个参数类型为（访问函数类型，Variant），返回类型为访问函数返回类型的一个接口函数，常量的类型被类型擦除了因为不属于函数类型。`convert_to_array`就是将对`Storage`的访问转化成数组，比如`Storage<int, char>`可以转换对`Storage<int, char>`和`Storage<char>`访问的数组, 对应的常量访问就是`0`, `1`记录到`dispatch`的模板参数中，`get_index_element`可以通过记录的模板参数常量值来递归出需要访问的最终Storage的成员数据
> 0 => `Storage<int, char>::ele`
> 1 => `Storage<int, char> :: rest :: ele`

`dispatch<0>, dispatch<1>`实例化后的函数类型就是一个公共类型 `ReturnType(F, Storage<int, char>)`,这样一个公共类型就可以通过数组存储，数组的元素就可以通过非编译期的下标值来访问。

https://godbolt.org/z/4YxbxKffd