类型萃取&类的模板特化

类模板的特化

1、全特化
2、偏特化（局部特化）

1、全特化

template <>
class Data<int, char>
{
public :
    Data()
    {
        cout<<"Data(int, char)"<<endl;
    }

private :
    int _d1 ;
    char _d2 ;
};

2、偏特化（局部特化）

偏特化分为两种

1特化部分参数

template <class T1>
class Data<T1, double>
{
public :
    Data()
    {
        cout<<"Data(T1, double)"<<endl;
    }

private :
    T1 _d1 ;
    char _d2 ;
};

2.参数指定特定类型

template <class T1, class T2>
class Data<T1*, T2*>
{
public :
    Data()
    {
        cout<<"Data(T1*, T2*)"<<endl;
    }

private :
    T1 _d1 ;
    T2* _d2 ;
};

template <class T1, class T2>
class Data<T1&, T2&>
{
public:
    Data(const T1& d3)
        :_d3(d3)
    {
        cout << "Data(T1&, T2&)" << endl;
    }

private:
    T1* _d1;
    T2* _d2;
    const T1& _d3;
    //T2& _d4;引用必须初始化
};

特化可以说就是模板的一种特殊化

所以模板的全特化和偏特化都是在已定义的模板基础之上，不能单独存在。

void test()
{
    Data<int, int> d1;
    Data<int, char> d2;
    Data<int, double> d3;
    Data<int*, double*> d4;
    Data<int*, int*> d5;
    Data<int&, int&> d6(10);
}

类型萃取

template<class T>
struct __TypeTraits
{
    typedef __FalseType IsPODType; // 内嵌重定义
};

template<>
struct __TypeTraits<int>
{
    typedef __TrueType IsPODType; 
};

template<>
struct __TypeTraits<char>
{
    typedef __TrueType IsPODType; 
};

template<>
struct __TypeTraits<double>
{
    typedef __TrueType IsPODType; 
};

这里我们用顺序表copy时，对于不同类型，不同的拷贝方式来举例

template<class T>
T* __TypeCopy(T* dst, const T* src, size_t n, __TrueType)
{
    // int 、char...
    cout<<"memcpy"<<endl;
    return (T*)memcpy(dst, src, n*sizeof(T));
}

template<class T>
T* __TypeCopy(T* dst, const T* src, size_t n, __FalseType)
{
    // string
    cout<<"for+operator="<<endl;
    for (size_t i = 0; i < n; ++i)
    {
        dst[i] = src[i]; // operator=
    }

    return dst;
}

template<class T>
T* TypeCopy(T* dst, const T* src, size_t n)
{
    return __TypeCopy(dst, src, n, __TypeTraits<T>::IsPODType());
}