C++类型萃取

类型萃取依靠的就是模版的特化，模版的特化又分为全特化和偏特化，根据不同的情况做相应的调用。

函数模版特化

函数模版只有全特化，而没有偏特化。没有偏特化的原因是已经有了函数重载。
通用模版并不总是正确的，在某些情况下有可能是错误的。
例如:

#include <iostream>
using namespace std;
template<class T>
int Max(T x,T y)
{
    return x>y?x:y;
}
int main()
{
    int a = 3;
    int b = 10;
    cout<<"Max:"<<Max(a,b)<<endl;
    char str1[] = "hello";
    char str2[] = "world";
    cout<<"Max:"<<Max(str1,str2)<<endl;//输出错误
    return 0;
}

这个时候我们知道数字的比较和字符串的比较方式是不同的，不能一概而论，可以说全特化就是为此而生，它可以让某些特殊情况得到正确的处理。模版函数特化形式如下:

template<>
返回值 函数名<Type>(参数列表)
{
    //函数体
}

注意事项:在模版特化中实参类型必须与特化版本完全一致，若有小小的不同，编译器就会为实参模版实例化一个实例，这非常有可能出现错误。

类模版的全特化与偏特化

全特化与偏特化是相当于类模板而言的。全特化是限定死模板实现的具体类型，而偏特化是针对于当模板有多个类型时，限定了其中的一部分。

//全特化
template<>
class A<int,char>
{
public:
    void Print(int x,char c)
    {
        cout<<"x = "<<x<<endl;
        cout<<"c = "<<c<<endl;
    }

};
//偏特化
template<class T>
class A<int,T>
{
public:
    void Print(int x,T c)
    {
        cout<<"x = "<<x<<endl;
        cout<<"c = "<<c<<endl;
    }

};

注意：对于主模板类、全特化类、偏特化类的调用优先级的次序为：
全特化类 > 偏特化类 > 主模板类

POD类型萃取举例

#include <iostream>
using namespace std;

//POD:基本类型，指C++中与C兼容的类型
struct _TrueType
{
    bool Get()
    {
        return true;
    }
};

struct _FalseType
{
    bool Get()
    {
        return false;
    }
};

template<class _Tp>
struct TypeTraits
{
    typedef _FalseType _IsPODType;//如果不是内置类型，则IsPODType是FalseType 
};

//1.0
template<>
struct TypeTraits<bool>
{
    typedef _TrueType _IsPODType; //如果是内置类型则IsPODType是TrueType  
};
//2.0
template<>
struct TypeTraits<char>
{
    typedef _TrueType _IsPODType; //如果是内置类型则IsPODType是TrueType  
};
//3.0
template<>
struct TypeTraits<unsigned char>
{
    typedef _TrueType _IsPODType; //如果是内置类型则IsPODType是TrueType  
};
//4.0
template<>
struct TypeTraits<short>
{
    typedef _TrueType _IsPODType; //如果是内置类型则IsPODType是TrueType  
};

//使用参数推导的萃取处理
template<class T>
void Copy(const T* src, T* dst, size_t size, _FalseType)
{
    cout << "_FalseType:" << typeid(T).name() << endl;
    for(size_t i = 0;i < size;++i)
    {
        dst[i] = src[i];
    }
}
 //内置类型用memcpy效率好
template<class T>
void Copy(const T* src, T* dst, size_t size, _TrueType)
{
    cout << "_TrueType:" << typeid(T).name() << endl;
    memcpy(dst, src, sizeof(T)*size);
}

//测试
void Test()
{
    int a1[10] = { 1,2,3 };
    int a2[10] = { 0 };
    //内置类型
    Copy(a1, a2, 10, TypeTraits<int>::_IsPODType());
    //非内置类型
    string s1[10] = { "1","2","3","4444444444444" };
    string s2[10] = { "11","22","33" };
    Copy(s1, s2, 10, TypeTraits<string>::_IsPODType());
    Copy(a1, a2, 10, TypeTraits<int>::_IsPODType());
}

int main()
{
    Test();
    system("pause");
    return 0;

总结：类型萃取是在模板的基础上区分内置类型与自定义类型的，即将内置类型全部特化，然后再进行区分。