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. is_same是模版，integral_constant也是模版

2. true_type和false_type是integral_constant实例化的类型

3.is_same通用的模版继承了false_type

4.is_same的偏特化模版继承了true_type

5.is_same模版实参类型一致时，会实例化偏特化模版，而偏特化模版继承了true_type

6.integral_constant<bool, true> 即truetype的value是true

is_same和static_assert配合使用，可以在编译期进行强大的类型检查。使用例子如下：

 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()};

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