关于variant的实现参考我前面的博文，不过这第一个版本还不够完善，主要有这几个问题：
- 内部的缓冲区是原始的char[]，没有考虑内存对齐；
- 没有visit功能。
- 没有考虑赋值构造函数的问题，存在隐患。
这次将解决以上问题，还将进一步增强variant的功能。增加的功能有：
- 通过索引位置获取类型。
- 通过类型获取索引位置。
c++11的内存对齐
关于内存对齐的问题，将用c++11的std::aligned_storage来代替char[]数组，它的原型是：
template< std::size_t Len, std::size_t Align = /*default-alignment*/ > struct aligned_storage;
其中Len表示所存储类型的size，Align表示该类型内存对齐的大小，通过sizeof(T)可以获取T的size，通过alignof(T)可以获取T内存对齐大小，所以std::aligned_storage的声明是这样的：std::aligned_storage<sizeof(T), alignof(T)>。alignof是vs2013 ctp中才支持的，如果没有该版本则可以用std::alignment_of来代替，可以通过std::alignment_of<T>::value来获取内存对齐大小。故std::aligned_storage可以这样声明：std::aligned_storage<sizeof(T), std::alignment_of<T>::value>。
这里要说一下alignof和std::alignment_of的区别，主要区别：
- std::alignment_of对于数组来说，是获取数组中元素类型内存对齐大小，如果非数组则是类型本身的内存对齐大小，因此使用时要注意这一点。其实std::alignment_of可以由align来实现：
template<class T> struct remove_all_extents { typedef T type;}; template<class T> struct remove_all_extents<T[]> { typedef typename remove_all_extents<T>::type type; }; template<class Tp, std::size_t N> struct remove_all_extents<T[N]> { typedef typename remove_all_extents<T>::type type; template< class T > struct alignment_of : std::integral_constant< std::size_t, alignof(typename std::remove_all_extents<T>::type) > {};
- alignof和sizeof有点类似，它可以应用于变长类型，比如alignof(Args)...，而std::alignment_of则不行。
variant赋值构造函数的问题
variant如果通过默认赋值函数赋值的话会造成两个variant的缓冲区都是一个，会导致重复析构。variant的赋值函数需要做两件事，第一是借助于赋值的variant的缓冲区取得其实际的类型；第二用赋值的variant种实际的类型构造出当前variant的实际类型。赋值函数的左值和右值版本的实现如下：
Variant(Variant<Types...>&& old) : m_typeIndex(old.m_typeIndex) { Helper_t::move(old.m_typeIndex, &old.m_data, &m_data); } Variant(const Variant<Types...>& old) : m_typeIndex(old.m_typeIndex) { Helper_t::copy(old.m_typeIndex, &old.m_data, &m_data); }
右值版本Helper_t::move的内部是这样的：new (new_v) T(std::move(*reinterpret_cast<T*>(old_v)));
左值版本Helper_t::copy的内部是这样的：new (new_v) T(*reinterpret_cast<const T*>(old_v));
右值版本可以直接将原对象move走，左值版本则需要拷贝原来的对象。
variant的visit功能
boost.variant中可以使用apply_visitior来访问variant中实际的类型，具体的做法是先创建一个从boost::static_visitor<T>派生的访问者类，这个类中定义了访问variant各个类型的方法，接着将这个访问者对象和vairant对象传到boost::apply_visitor(visitor, it->first)实现vairant的访问。一个简单的例子是这样的：
//创建一个访问者类，这个类可以访问vairant<int,short,double,std::string> struct VariantVisitor : public boost::static_visitor<void> { void operator() (int a) { cout << "int" << endl; } void operator() (short val) { cout << "short" << endl; } void operator() (double val) { cout << "double" << endl; } void operator() (std::string val) { cout << "string" << endl; } }; boost::variant<int,short,double,std::string> v = 1; boost::apply_visitor(visitor, it->first); //将输出int
实际上这也是标准的访问者模式的实现，这种方式虽然可以实现对variant内部实际类型的访问，但是有一个缺点是有点繁琐，还需要定义一个函数对象，不够方便。c++11中有了lambda表达式了，是不是可以用lambda表达式来替代函数对象呢？如果直接通过一组lambda表达式来访问实际类型的话，那将是更直观而方便的访问方式，不再需要从boost::static_visitor派生了，也不需要写一堆重载运算符。我希望这样访问vairant的实际类型：
typedef Variant<int, double, string, int> cv; cv v = 10; v.Visit([&](double i){cout << i << endl; }, [](short i){cout << i << endl; }, [=](int i){cout << i << endl; },[](string i){cout << i << endl; }); //结果将输出10
这种方式比boost的访问方式更简洁直观。这个版本中将增加这种内置的访问方式。
比boost.variant多的更能
这个版本增加了通过索引获取类型和通过类型获取索引的功能，你可以从variant中获取更多信息，boost.variant中是没有这两个接口的。
typedef Variant<int, double, string, int> cv; cv v = 10; cout << typeid(cv::IndexType<1>).name() << endl; //将输出double int i = v.GetIndexOf<string>(); //将输出索引位置2
c++11版本的variant
下面来看看c++11版本的vairant的具体实现了：
#include <typeindex> #include <iostream> #include <type_traits> using namespace std; template <typename T> struct function_traits : public function_traits<decltype(&T::operator())> {}; // For generic types, directly use the result of the signature of its ‘operator()‘ template <typename ClassType, typename ReturnType, typename... Args> struct function_traits<ReturnType(ClassType::*)(Args...) const> // we specialize for pointers to member function { enum { arity = sizeof...(Args) }; // arity is the number of arguments. typedef ReturnType result_type; template <size_t i> struct arg { typedef typename std::tuple_element<i, std::tuple<Args...>>::type type; // the i-th argument is equivalent to the i-th tuple element of a tuple // composed of those arguments. }; typedef std::function<ReturnType(Args...)> FunType; typedef std::tuple<Args...> ArgTupleType; }; //获取最大的整数 template <size_t arg, size_t... rest> struct IntegerMax; template <size_t arg> struct IntegerMax<arg> : std::integral_constant<size_t, arg> { //static const size_t value = arg; //enum{value = arg}; }; //获取最大的align template <size_t arg1, size_t arg2, size_t... rest> struct IntegerMax<arg1, arg2, rest...> : std::integral_constant<size_t, arg1 >= arg2 ? IntegerMax<arg1, rest...>::value : IntegerMax<arg2, rest...>::value > { /*static const size_t value = arg1 >= arg2 ? static_max<arg1, others...>::value : static_max<arg2, others...>::value;*/ }; template<typename T, typename... Args> struct MaxAlign : std::integral_constant<int, (std::alignment_of<T>::value >MaxAlign<Args...>::value ? std::alignment_of<T>::value : MaxAlign<Args...>::value) > {}; template<typename T> struct MaxAlign<T> : std::integral_constant<int, std::alignment_of<T>::value >{}; //是否包含某个类型 template < typename T, typename... List > struct Contains : std::true_type {}; template < typename T, typename Head, typename... Rest > struct Contains<T, Head, Rest...> : std::conditional< std::is_same<T, Head>::value, std::true_type, Contains<T,Rest... >> ::type{}; template < typename T > struct Contains<T> : std::false_type{}; //获取第一个T的索引位置 // Forward template<typename Type, typename... Types> struct GetLeftSize; // Declaration template<typename Type, typename First, typename... Types> struct GetLeftSize<Type, First, Types...> : GetLeftSize<Type, Types...> { }; // Specialized template<typename Type, typename... Types> struct GetLeftSize<Type, Type, Types...> : std::integral_constant<int, sizeof...(Types)> { //static const int ID = sizeof...(Types); }; template<typename Type> struct GetLeftSize<Type> : std::integral_constant<int, -1> { //static const int ID = -1; }; template<typename T, typename... Types> struct Index : std::integral_constant<int, sizeof...(Types) - GetLeftSize<T, Types...>::value - 1>{}; //根据索引获取索引位置的类型 // Forward declaration template<int index, typename... Types> struct IndexType; // Declaration template<int index, typename First, typename... Types> struct IndexType<index, First, Types...> : IndexType<index - 1, Types...> { }; // Specialized template<typename First, typename... Types> struct IndexType<0, First, Types...> { typedef First DataType; }; template<typename... Args> struct VariantHelper; template<typename T, typename... Args> struct VariantHelper<T, Args...> { inline static void Destroy(type_index id, void * data) { if (id == type_index(typeid(T))) //((T*) (data))->~T(); reinterpret_cast<T*>(data)->~T(); else VariantHelper<Args...>::Destroy(id, data); } inline static void move(type_index old_t, void * old_v, void * new_v) { if (old_t == type_index(typeid(T))) new (new_v) T(std::move(*reinterpret_cast<T*>(old_v))); else VariantHelper<Args...>::move(old_t, old_v, new_v); } inline static void copy(type_index old_t, const void * old_v, void * new_v) { if (old_t == type_index(typeid(T))) new (new_v) T(*reinterpret_cast<const T*>(old_v)); else VariantHelper<Args...>::copy(old_t, old_v, new_v); } }; template<> struct VariantHelper<> { inline static void Destroy(type_index id, void * data) { } inline static void move(type_index old_t, void * old_v, void * new_v) { } inline static void copy(type_index old_t, const void * old_v, void * new_v) { } }; template<typename... Types> class Variant { typedef VariantHelper<Types...> Helper_t; enum { data_size = IntegerMax<sizeof(Types)...>::value, //align_size = IntegerMax<alignof(Types)...>::value align_size = MaxAlign<Types...>::value //ctp才有alignof, 为了兼容用此版本 }; using data_t = typename std::aligned_storage<data_size, align_size>::type; public: template<int index> using IndexType = typename IndexType<index, Types...>::DataType; Variant(void) :m_typeIndex(typeid(void)), m_index(-1) { } ~Variant() { Helper_t::Destroy(m_typeIndex, &m_data); } Variant(Variant<Types...>&& old) : m_typeIndex(old.m_typeIndex) { Helper_t::move(old.m_typeIndex, &old.m_data, &m_data); } Variant(const Variant<Types...>& old) : m_typeIndex(old.m_typeIndex) { Helper_t::copy(old.m_typeIndex, &old.m_data, &m_data); } template <class T, class = typename std::enable_if<Contains<typename std::remove_reference<T>::type, Types...>::value>::type> Variant(T&& value) : m_typeIndex(typeid(void)) { Helper_t::Destroy(m_typeIndex, &m_data); typedef typename std::remove_reference<T>::type U; new(&m_data) U(std::forward<T>(value)); m_typeIndex = type_index(typeid(T)); } template<typename T> bool Is() const { return (m_typeIndex == type_index(typeid(T))); } bool Empty() const { return m_typeIndex == type_index(typeid(void)); } type_index Type() const { return m_typeIndex; } template<typename T> T& Get() { if (!Is<T>()) { cout << typeid(T).name() << " is not defined. " << "current type is " << m_typeIndex.name() << endl; throw std::bad_cast(); } return *(T*) (&m_data); } template<typename T> int GetIndexOf() { return Index<T, Types...>::value; } template<typename F> void Visit(F&& f) { using T = typename function_traits<F>::arg<0>::type; if (Is<T>()) f(Get<T>()); } template<typename F, typename... Rest> void Visit(F&& f, Rest&&... rest) { using T = typename function_traits<F>::arg<0>::type; if (Is<T>()) Visit(std::forward<F>(f)); else Visit(std::forward<Rest>(rest)...); } bool operator==(const Variant& rhs) const { return m_typeIndex == rhs.m_typeIndex; } bool operator<(const Variant& rhs) const { return m_typeIndex < rhs.m_typeIndex; } private: data_t m_data; std::type_index m_typeIndex;//类型ID };
测试代码：
typedef Variant<int, double, string, int> cv; //根据index获取类型 cout << typeid(cv::IndexType<1>).name() << endl; //根据类型获取索引 cv v=10; int i = v.GetIndexOf<string>(); //通过一组lambda访问vairant v.Visit([&](double i){cout << i << endl; }, [&](short i){cout << i << endl; }, [](int i){cout << i << endl; }, [](string i){cout << i << endl; } ); bool emp1 = v.Empty(); cout << v.Type().name() << endl;
c++11版本的vairant不仅仅比boost的variant更好用也更强大，经过测试发现性能也优于boost.variant，因此可以在项目中用这个c++11版本的variant替代boost的variant。实际上我的并行计算库中已经用自己的variant和any代替了boost.variant和boost.any，从而消除了对boost的依赖。
c++11 boost技术交流群：296561497，欢迎大家来交流技术。