【C++模版之旅】项目中一次活用C++模板(traits)的经历 -新注解

问题与需求：

请读者先看这篇文章，【C++模版之旅】项目中一次活用C++模板(traits)的经历。 对于此篇文章提出的问题，我给出一个新的思路。

talking is cheap,show me the code.文章结尾处，有最终版。

初版代码：

class ExportData
{
    union
    {
        string * sp;
        long*  lp;
        double* dp;
        void* vp;

    };
    enum my_type {SP,LP,DP} types;
    static unordered_map<type_index,my_type> typeMap;
public:

    template <typename T> ExportData(T t)
    {
        if(typeMap.find(typeid(t))==typeMap.end())
            assert(false);
        vp=new T(t);
        types= typeMap[typeid(T)];
    }
    template <typename T> void setData(T t)
    {
        if(typeMap.find(typeid(t))==typeMap.end())
            assert(false);
        switch(types)
        {
        case SP:
            delete sp;
            break;
        case DP:
            delete dp;
            break;
        case LP:
            delete lp;
            break;
        }
        vp=new T(t);
        types=typeMap[typeid(T)];

    }
    template <typename T> void getData(T& t)
    {
        if(typeMap[typeid(T)]!=types) assert(false);
        t=*(static_cast<T*>(vp));
    }

};

unordered_map<type_index,ExportData::my_type> ExportData::typeMap
{
    {typeid(string),ExportData::my_type::SP},
    {typeid(long),ExportData::my_type::LP},
    {typeid(double),ExportData::my_type::DP},
};

重复一下，四点需求：

1. ExportData需要仅支持整型（long），浮点型（double），字符串（string）以及二进制（void*, size）4种类型的操作。（我并没有考虑二进制）

2. ExportData需要考虑结构的尺寸，尽量减少空间冗余（我使用联合体，保存各种类型数据的指针）

3. 即使对以上4种不同数据类型进行操作，还是希望在从ExportData中Get或Set真实数据时，使用的方法能统一（方法显然是统一的，因为使用的是模版）

4. 当调用者尝试使用了以上4种类型以外的数据类型时，能通过返回错误让调用方知道类型不匹配（为了方便演示，试图使用其他类型都会导致断言失败，终止运行）

如果你也讨厌代码中存在swtich，可以再次使用表驱动法。代码如下所示：

class DeleteLong
{
public:
    void operator()(void *p)
    {
        delete static_cast<long*>(p);
    }
};
class DeleteString
{
public:
    void operator()(void *p)
    {
        delete static_cast<string*>(p);
    }
};
class DeleteDouble
{
public:
    void operator()(void *p)
    {
        delete static_cast<double*>(p);
    }
};

class ExportData
{
    union
    {
        string * sp;
        long*  lp;
        double* dp;
        void* vp;

    };
    enum my_type {SP,LP,DP} types;//change it to object.
    static unordered_map<type_index,my_type> typeMap;
    static vector<function<void(void*)>> deleters;
public:

    template <typename T> ExportData(T t)
    {
        static_assert(is_same<T,string>::value||is_same<T,double>::value||is_same<T,long>::value,"never support!");//感谢园友 崔好好提醒
        // if(typeMap.find(typeid(t))==typeMap.end())
        //     assert(false);
        vp=new T(t);
        types= typeMap[typeid(T)];
    }
    template <typename T> void setData(T t)
    {
        static_assert(is_same<T,string>::value||is_same<T,double>::value||is_same<T,long>::value,"never support!");//感谢园友 崔好好提醒
        (deleters[types])(vp);
        vp=new T(t);//可以改用placement new
        types=typeMap[typeid(T)];

    }
    template <typename T> void getData(T& t)
    {

        static_assert(is_same<T,string>::value||is_same<T,double>::value||is_same<T,long>::value,"never support!");//感谢园友 崔好好提醒
        if(typeMap[typeid(T)]!=types) assert(false);
        t=*(static_cast<T*>(vp));
    }
    //这里可以改成重载，void getData(long& t){...} void getData(sting& t){....} void getData(double& t){...}调用其他类型则编译错误

};

unordered_map<type_index,ExportData::my_type> ExportData::typeMap
{
    {typeid(string),ExportData::my_type::SP},
    {typeid(long),ExportData::my_type::LP},
    {typeid(double),ExportData::my_type::DP},
};
vector<function<void(void*)>> ExportData::deleters {DeleteString(),DeleteLong(),DeleteDouble(),};

这里是测试代码：

int main()
{

    long i=;
    long j=;
    string s="Hello";
    string ss;
    ExportData p(i);
    p.setData(++i);
    p.getData(j);
    p.setData(s);
    p.getData(ss);
    cout<<j<<endl;
    cout<<ss<<endl;
    return ;
}

这是一个精简版，使用重载：

class ExportData
{
    union
    {
        string * sp;
        long*  lp;
        double* dp;
    };
public:
    ExportData(long t)
    {
        lp=new long(t);
    }
    ExportData(double t)
    {
        dp=new double(t);
    }
    ExportData(string t)
    {
        sp=new string(t);
    }
    void    setData(long t)
    {
        *lp=t;
    }
    void   setData(double t)
    {
        *dp=t;
    }
    void setData(string t)
    {
        *sp=t;
    }
    void getData(long& t)
    {
        t=*lp;
    }
    void getData(double& t)
    {
        t=*dp;
    }
    void getData(string& t)
    {
        t=*sp;
    }
    //1.析构函数需要解决内存泄露问题 2.如当前指针指向double，setData函数传入string，会发生内存错误。
};

这个版本存在两个严重的问题，1.析构函数需要解决内存泄露问题 2.如当前指针指向double，setData函数传入string，会发生内存错误。

我觉得第二个错误，没办法在编译期阻止用户编译，因为在setData的时候，无法在编译期知道哪个指针有效。

这段代码额外的优点：

1.代码更加的短小紧凑。（代码量减少）
2.ExportData对象使用起来更容易。
3.ExportData对象仅有两个数据，一个是指针联合体，一个是枚举值。（性能更优）
4.我在作者提出4点需求基础上添加了一个额外功能，ExportData可以动态的改变持有数据的类型。（功能更强）
5. 类中所有方法如果不使用模版而是使用重载，虽然会导致代码量大增，但好处是我们可以在编译期提示用户ExportData不支持某些类型，也能提高一点运行速度。要不要这么做，可具体问题具体分析。
6.因为使用模版，所以可扩展性强，当增加支持类型时，只需改动少量代码。（可扩展性更好）

最后，这段代码是示例代码，也许经不起推敲，那么引用原文作者的话，“我想肯定还有更好的解决方法，比如可以尝试在编译时就提示类型不支持而不是在运行时通过返回错误来提示。如果有更好的解决方案，欢迎一起讨论。”，ME TOO。

 

typetraits版：

 struct A{~A(){cout<<"delete A..."<<endl;}};
 template<typename T>
 struct TypeTraits
 {
        typedef void TYPE;
 };
 template<>
 struct TypeTraits<std::string>
 {
        typedef std::string TYPE;
 };
 template<>
 struct TypeTraits<long>
 {
        typedef long TYPE;
 };
 template<>
 struct TypeTraits<A>
 {
        typedef A TYPE;
 };
 template<>
 struct TypeTraits<double>
 {

        typedef double TYPE;
 };

 class DeleteLong
 {
 public:
     void operator()(void *p)
     {
         delete static_cast<long*>(p);
     }
 };
 class DeleteString
 {
 public:
     void operator()(void *p)
     {
         delete static_cast<string*>(p);
     }
 };
 class DeleteDouble
 {
 public:
     void operator()(void *p)
     {
         delete static_cast<double*>(p);
     }
 };
 class DeleteA
 {
 public:
     void operator()(void *p)
     {
         delete static_cast<A*>(p);
     }
 };

 class ExportData
 {

     void* vp;
     enum my_type {SP,LP,DP,AP} types;
     static unordered_map<type_index,my_type> typeMap;
     static vector<function<void(void*)>> deleters;
 public:

     template <typename T> ExportData(const T& t)
     {

         static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");
         vp=new T(t);
         types= typeMap[typeid(T)];
     }
     template <typename T> void setData(const T& t)
     {
         static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");
         assert(types==typeMap[typeid(T)]);
         *(static_cast<T*>(vp))=t;
     }
     template <typename T> void getData(T& t)
     {
         static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");
         assert(types==typeMap[typeid(T)]);
         t=*(static_cast<T*>(vp));
     }

     ~ExportData()
     {

        (deleters[types])(vp);
     }

 };

 unordered_map<type_index,ExportData::my_type> ExportData::typeMap
 {
     {typeid(string),ExportData::my_type::SP},
     {typeid(long),ExportData::my_type::LP},
     {typeid(double),ExportData::my_type::DP},
     {typeid(A),ExportData::my_type::AP}
 };
 vector<function<void(void*)>> ExportData::deleters {DeleteString(),DeleteLong(),DeleteDouble(),DeleteA()};

1.删除ExportData对象持有的数据，最好使用标准delete删除数据，谨记使用内存擦除方法无法清除用户自定义类型（当数据持有指针时）

2.static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");静态断言，当用户使用不支持类型时，立即阻止用户编译。

3.assert(types==typeMap[typeid(T)]);运行时断言，当运行时发现类型异常，立即退出程序。

4.void*指针承担擦除类型的重任

 typelist版本

 template<typename... _Elements> struct Typelist;
 template<typename T,typename U> struct is_contained;
 template<typename T,typename... Tail> struct is_contained<T,Typelist<T,Tail...>>:public true_type{};
 template<typename T> struct is_contained<T, Typelist<>>:public false_type{};
 template<typename T,typename Head,typename... Tail> struct is_contained<T,Typelist<Head,Tail...>>:public is_contained<T,Typelist<Tail...>>{};

struct A{~A(){cout<<"delete A..."<<endl;}};
class DeleteLong
{
public:
    void operator()(void *p)
    {
        delete static_cast<long*>(p);
    }
};
class DeleteString
{
public:
    void operator()(void *p)
    {
        delete static_cast<string*>(p);
    }
};
class DeleteDouble
{
public:
    void operator()(void *p)
    {
        delete static_cast<double*>(p);
    }
};
class DeleteA
{
public:
    void operator()(void *p)
    {
        delete static_cast<A*>(p);
    }
};

class ExportData
{

    void* vp;
    enum my_type {SP,LP,DP,AP} types;
    typedef Typelist<string,long,double,A> list;
    static unordered_map<type_index,my_type> typeMap;
    static vector<function<void(void*)>> deleters;
public:

    template <typename T> ExportData(const T& t)
    {

        static_assert(is_contained<T,list>::value,"not supprot");
        vp=new T(t);
        types= typeMap[typeid(T)];
    }
    template <typename T> void setData(const T& t)
    {
         static_assert(is_contained<T,list>::value,"not supprot");
        assert(types==typeMap[typeid(T)]);
        *(static_cast<T*>(vp))=t;
    }
    template <typename T> void getData(T& t)
    {
         static_assert(is_contained<T,list>::value,"not supprot");
        assert(types==typeMap[typeid(T)]);
        t=*(static_cast<T*>(vp));
    }

    ~ExportData()
    {

       (deleters[types])(vp);
    }

};

unordered_map<type_index,ExportData::my_type> ExportData::typeMap
{
    {typeid(string),ExportData::my_type::SP},
    {typeid(long),ExportData::my_type::LP},
    {typeid(double),ExportData::my_type::DP},
    {typeid(A),ExportData::my_type::AP}
};
vector<function<void(void*)>> ExportData::deleters {DeleteString(),DeleteLong(),DeleteDouble(),DeleteA()};