使用c++11打造好用的variant方法

boost中的variant的基本用法:

代码如下:

typedef variant<int,char, double> vt;
vt v = 1;
v = '2';
v = 12.32;

  用variant一个好处是可以擦除类型,不同类型的值都统一成一个variant,虽然这个variant只能存放已定义的类型,但这在很多时候已经够用了。 取值的时候,通过get<T>(v)来获取真实值。然而,当T类型与v的类型不匹配时,会抛出一个bad_cast的异常来。boost的variant抛出的异常往往没有更多的信息,不知道到底是哪个类型转换失败,导致发生异常调试时很不方便。因此,就考虑用c++11去实现一个vairiant, 这个variant可以很容易知道取值时,是什么类型转换失败了。

打造variant需要解决的问题:
第一,要在内部定义一个char缓冲区。

  缓冲区用来存放variant的值,这个值是variant定义的多种类型中的某种类型的值,因此,这个缓冲区要足够大,能够存放类型最大(sizeof(Type))的值才可以,这个缓冲区的大小还必须在编译期计算出来。因此需要首先要解决的是variant值存放的缓冲区定义的问题。

第二,要解决赋值的问题。

  将值赋给vairiant时,需要将该值的类型ID记录下来,以便在后面根据类型取值。将值保存到内部缓冲区时,还需要用palcement new在缓冲区创建对象。另外,还要解决一个问题,就是赋值时需要检查variant中已定义的类型中是否含有该类型,如果没有则编译不通过,以保证赋值是合法的。

第三,要解决取值的问题。

  通过类型取值时,要判断类型是否匹配,如果不匹配,将详情打印出来,方便调试。

打造variant的关键技术:

1.找出最大的typesize
第一个问题中需要解决的问题是如何找出多种类型中,size最大的那个类型的size。看看如何从多种类型中找出最大类型的size。

代码如下:

template<typename T, typename... Args>
struct MaxType : std::integral_constant<int,
(sizeof(T)>MaxType<Args...>::value ? sizeof(T) : MaxType<Args...>::value) >

{};

template<typename T>
struct MaxType<T> : std::integral_constant<int, sizeof(T) >{};

通过这个MaxType就可以在编译期获取类型中最大的maxsize了:MaxType<Types...>::value。

2.类型检查和缓冲区中创建对象
第二个问题中需要解决两个问题,1.检查赋值的类型是否在已定义的类型中;2.在缓冲区中创建对象及析构;

先看看如何判断类型列表中是否含有某种类型:

代码如下:

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{};

通过bool值Contains<T, Types>::vaule就可以判断是否含有某种类型。

再看看如何在缓冲区中创建对象。

通过placement new在该缓冲区上创建对象,new(data) T(value);其中data表示一个char缓冲区,T表示某种类型。在缓冲区上创建的对象还必须通过~T去析构,因此还需要一个析构vairiant的帮助类:

代码如下:

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();
else
VariantHelper<Args...>::Destroy(id, data);
}
};

template<> struct VariantHelper<>  {
inline static void Destroy(type_index id, void * data) { }
};

通过VariantHelper::Destroy函数就可以析构variant了。

3.取值问题
第三个问题中需要解决取值问题,如果发生异常,就打印出详细信息。这个就比较简单了,看后面的实现代码就行了。

c++11中完整的variant是如何实现的:


代码如下:

#include <typeindex>
#include <iostream>
#include <type_traits>
using namespace std;

template<typename T, typename... Args>
struct MaxType : std::integral_constant<int,
(sizeof(T)>MaxType<Args...>::value ? sizeof(T) : MaxType<Args...>::value) >

{};

template<typename T>
struct MaxType<T> : std::integral_constant<int, sizeof(T) >{};

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{};

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();
else
VariantHelper<Args...>::Destroy(id, data);
}
};

template<> struct VariantHelper<>  {
inline static void Destroy(type_index id, void * data) { }
};

template<typename... Types>
class Variant
{
typedef VariantHelper<Types...> Helper_t;
public:

Variant(void) :m_typeIndex(typeid(void))
{
}

~Variant()
{
Helper_t::Destroy(m_typeIndex, &m_data);
}

template<typename T>
bool Is()
{
return (m_typeIndex == type_index(typeid(T)));
}

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 <class T,
    class = typename std::enable_if<Contains<typename

std::remove_reference<T>::type, Types...>::value>::type>
    Variant(T&& value) : m_typeIndex(type_index(typeid(T)))
    {
        Helper_t::Destroy(m_typeIndex, &m_data);
        typedef typename std::remove_reference<T>::type U;
        new(m_data) U(std::forward<T>(value));
    }

private:
char m_data[MaxType<Types...>::value];
std::type_index m_typeIndex;
};

测试代码:

代码如下:

void TestVariant()
{
    typedef Variant<int, char, double> cv;
    int x = 10;

cv v =x;
    v = 1;
    v = 1.123;
    v = "";//compile error
    v.Get<int>(); //1
    v.Get<double>(); //1.23
    v.Get<short>(); //exception: short is not defined. current type is

int.
    v.Is<int>();//true
}

总结:c++11实现的variant在用法上和boost.variant保持一致,但实现更简洁,50行代码搞定。而且还能在抛出异常时提示详细信息,方便调试。

c++11 boost技术交流群:296561497,欢迎大家来交流技术。

(0)

相关推荐

  • 利用C++实现从std::string类型到bool型的转换

    利用输入字符串流:std::istringstream 复制代码 代码如下: bool b;std::string s = "true";std::istringstream(s) >> std::boolalpha >> b; 但当字符串s为"1"时,上面的代码无法正确转换,此时应该用: 复制代码 代码如下: bool b;std::string s = "1";istringstream(s) >> b;

  • C++11中lambda、std::function和std:bind详解

    前言 在C++11新标准中,语言本身和标准库都增加了很多新内容,本文只涉及了一些皮毛.不过我相信这些新特性当中有一些,应该成为所有C++开发者的常规装备.本文主要介绍了C++11中lambda.std::function和std:bind,下面来一起看看详细的介绍吧. lambda 表达式 C++11中新增了lambda 表达式这一语言特性.lambda表达式可以让我们快速和便捷的创建一个"函数". 下面是lambda表达式的语法: [ capture-list ] { body }

  • 通过c++11改进我们的模式之改进命令模式

    模式虽然精妙,却难完美,比如观察者模式中观察者生命周期的问题:比如访问者模式中循环依赖的问题等等:其它很多模式也存在这样那样的一些不足之处,如使用场景受限.实现复杂.不够简洁.不够通用等.但我觉得不足之处大都是可以采取一些手法去弥补去改进的,比如用c++11的新特性来改进.因此,便有了c++11改进我们的模式这个系列.这次我要讲的是如何使用c++11改进命令模式.关于命令模式 命令模式的作用是将请求封装为一个对象,将请求的发起者和执行者解耦,支持对请求排队以及撤销和重做.它的类图如下: 由于将请

  • c++11新增的便利算法实例分析

    C++是一门应用非常广泛的程序设计语言,而c++11则新增加了一些便利的算法,这些新增的算法使我们的代码写起来更简洁方便,本文列举一些常用的新增算法,算是做个总结分析,更多的新增算法读者可以参考:http://en.cppreference.com/w/cpp/algorithm. 算法库新增了三个用于判断的算法all_of.any_of和none_of,定义如下: template< class InputIt, class UnaryPredicate > bool all_of( Inp

  • c++ std::invalid_argument应用

    首先说明invalid_argument是一个类(class invalid_argument;),它的继承关系如下 exception-------->logic_error--------->invalid_argument invalid_argument原型是 复制代码 代码如下: class invalid_argument:public logic_error { public: explicit invalid_argument (const string& what_a

  • VC++实现CStdioFile写入及读取文件并自动换行的方法

    本文所述CStdioFile可实现在VC++中主要用来写入及读出文件的功能,继承自CFile类,它会自动处理 "\r\n",遇到"\n"自动添加\r并设置光标在当前行,它同时可以自动换行,不过使用CStdioFile在处理大文件时速度有些慢, 用CStdioFile写入读取文件实现代码如下: LPTSTR filter=_T("Playlist Files(.txt)|*.txt|"); CString tempPath; CFileDialog

  • 浅析C++11新特性的Lambda表达式

    lambda简介 熟悉Python的程序员应该对lambda不陌生.简单来说,lambda就是一个匿名的可调用代码块.在C++11新标准中,lambda具有如下格式: [capture list] (parameter list) -> return type { function body } 可以看到,他有四个组成部分: 1.capture list: 捕获列表 2.parameter list: 参数列表 3.return type: 返回类型 4.function body: 执行代码

  • 理解C++编程中的std::function函数封装

    先来看看下面这两行代码: std::function<void(EventKeyboard::KeyCode, Event*)> onKeyPressed; std::function<void(EventKeyboard::KeyCode, Event*)> onKeyReleased; 这两行代码是从Cocos2d-x中摘出来的,重点是这两行代码的定义啊.std::function这是什么东西?如果你对上述两行代码表示毫无压力,那就不妨再看看本文,就当温故而知新吧. std::

  • 结合C++11新特性来学习C++中lambda表达式的用法

    在 C++ 11 中,lambda 表达式(通常称为 "lambda")是一种在被调用的位置或作为参数传递给函数的位置定义匿名函数对象的简便方法. Lambda 通常用于封装传递给算法或异步方法的少量代码行. 本文定义了 lambda 是什么,将 lambda 与其他编程技术进行比较,描述其优点,并提供一个基本示例. Lambda 表达式的各部分 ISO C++ 标准展示了作为第三个参数传递给 std::sort() 函数的简单 lambda: #include <algorit

  • C++ using namespace std 用法深入解析

    一 :<iostream>和<iostream.h>是不一样,前者没有后缀,实际上,在你的编译器include文件夹里面可以看到,二者是两个文件,打开文件就会发现,里面的代码是不一样的. 后缀为.h的头文件c++标准已经明确提出不支持了,早些的实现将标准库功能定义在全局空间里,声明在带.h后缀的头文件里,c++标准为了和C区别开,也为了正确使用命名空间,规定头文件不使用后缀.h. 因此,当使用<iostream.h>时,相当于在c中调用库函数,使用的是全局命名空间,也就

随机推荐