C++11 type_traits 之is_same源码分析

template<typename _Tp, _Tp __v>
    struct integral_constant
    {
      static const _Tp                      value = __v;
      typedef _Tp                           value_type;
      typedef integral_constant<_Tp, __v>   type;
    };
  
  /// typedef for true_type
  typedef integral_constant<bool, true>     true_type;

  /// typedef for false_type
  typedef integral_constant<bool, false>    false_type;



template<typename, typename>
    struct is_same
    : public false_type { };

  template<typename _Tp>
    struct is_same<_Tp, _Tp>
    : public true_type { };

  1 struct A{~A(){cout<<"delete A..."<<endl;}};
  2 template<typename T>
  3 struct TypeTraits
  4 {
  5        typedef void TYPE;
  6 };
  7 template<>
  8 struct TypeTraits<std::string>
  9 {
 10        typedef std::string TYPE;
 11 };
 12 template<>
 13 struct TypeTraits<long>
 14 {
 15        typedef long TYPE;
 16 };
 17 template<>
 18 struct TypeTraits<A>
 19 {
 20        typedef A TYPE;
 21 };
 22 template<>
 23 struct TypeTraits<double>
 24 {
 25 
 26        typedef double TYPE;
 27 };
 28 
 29 
 30 class DeleteLong
 31 {
 32 public:
 33     void operator()(void *p)
 34     {
 35         delete static_cast<long*>(p);
 36     }
 37 };
 38 class DeleteString
 39 {
 40 public:
 41     void operator()(void *p)
 42     {
 43         delete static_cast<string*>(p);
 44     }
 45 };
 46 class DeleteDouble
 47 {
 48 public:
 49     void operator()(void *p)
 50     {
 51         delete static_cast<double*>(p);
 52     }
 53 };
 54 class DeleteA
 55 {
 56 public:
 57     void operator()(void *p)
 58     {
 59         delete static_cast<A*>(p);
 60     }
 61 };
 62 
 63 class ExportData
 64 {
 65     void* vp;
 66     enum my_type {SP,LP,DP,AP} types;
 67     static unordered_map<type_index,my_type> typeMap;
 68     static vector<function<void(void*)>> deleters;
 69 public:
 70 
 71     template <typename T> ExportData(const T& t)
 72     {
 73         static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");
 74         vp=new T(t);
 75         types= typeMap[typeid(T)];
 76     }
 77     template <typename T> void setData(const T& t)
 78     {
 79         static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");
 80         assert(types==typeMap[typeid(T)]);
 81         *(static_cast<T*>(vp))=t;
 82     }
 83     template <typename T> void getData(T& t)
 84     {
 85         static_assert(is_same<typename TypeTraits<T>::TYPE,T>::value,"not support!");
 86         assert(types==typeMap[typeid(T)]);
 87         t=*(static_cast<T*>(vp));
 88     }
 89 
 90     ~ExportData()
 91     {
 92        (deleters[types])(vp);
 93     }
 94 
 95 };
 96 
 97 unordered_map<type_index,ExportData::my_type> ExportData::typeMap
 98 {
 99     {typeid(string),ExportData::my_type::SP},
100     {typeid(long),ExportData::my_type::LP},
101     {typeid(double),ExportData::my_type::DP},
102     {typeid(A),ExportData::my_type::AP}
103 };
104 vector<function<void(void*)>> ExportData::deleters {DeleteString(),DeleteLong(),DeleteDouble(),DeleteA()};