c++模板之萃取

假如，我们要设计一个_Copy的模板函数。我们为了提高效率采用memcpy，可以这样写：
template<typename T>
T* _Copy(T* dest, T* src, size_t n)
{
memcpy(dest, src, sizeof(T)*n);
return dest;
}

我们知道一般的类型（比如int，float，double，char等）进行复制的时候采用memcpy效率会高一些；而像string或者是其他的一些自定义类型（并且成员有指针类型的话），继续用mencpy将出现错误，采用for循环进行一个一个复制(赋值运算符重载)才是正确的方法。

自定义类型for循环代码：
template<typename T>
T* _Copy(T* dest, T* src, size_t n)
{
for (size_t i = 0; i < n; i++)
{
dest[i] = src[i]; //相当与调用string的赋值运算符重载
}
return dest;
}

但是采用for循环拷贝效率明显不如memcpy函数高，如何才能让程序在运行内置类型时调用memcpy，而拷贝自定义类型时防止错误调用for循环拷贝，两者兼顾呢？

为了进行不同的类型调用不同的方式进行拷贝，我们可以利用模板及模板的特化，在特化中返回它的类型进而进行判断要进行那种方式的拷贝。为了统一，也可在模板即特化中重命名它的类型，当所给的类型与所有特化有匹配时，执行一种方式进行拷贝；当所给的类型与所有特化没有匹配时，执行另一种方式进行拷贝。

以下是源代码：

#include <iostream>
using namespace std;
#include <string>
struct _TureType
{
    bool get()
    {
        return true;
    }
};
struct _FalseType
{
    bool get()
    {
        return false;
    }
};
   
//类型萃取
template<**typename** T>
struct TypeTraits      
{
    typedef _FalseType _IsPodType;
};
//特化TypeTraits进行类型判断(由于内置类型已经确定，而自定义类型不确定，因此经常特化内置类型)
template<>
struct TypeTraits<int>
{
    typedef _TureType _IsPodType;
}; 
template<>
struct TypeTraits<unsigned int>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<double>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<float>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<char>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<unsigned char>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<short>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<long>
{
    typedef _TureType _IsPodType;
};
template<>
struct TypeTraits<long long>
{
    typedef _TureType _IsPodType;
};
/*根据需要继续特化.................*/

template<typename T>
T* _Copy(T* dest, T* src, size_t n, _TureType)
{
        memcpy(dest, src, sizeof(T)*n);
        return dest;
}
template<typename T>
T* _Copy(T* dest, T* src, size_t n, _FalseType)
{
    for (size_t i = 0; i < n; i++)
    {
        dest[i] = src[i];       //相当与调用string的赋值运算符重载
    }
    return dest;
}
template<typename T>
T* _Copy(T*dest, T* src, size_t n)
{
    return _Copy(dest, src, n, TypeTraits<T>::_IsPodType());
}
//测试普通类型
void test1()
{
    int a[10] = { 2, 2, 3, 4, 5, 6, 7, 8, 8 };
    int b[10] = { 1, 1, 1, 1, 1, 1, 1, 1, 1 };
    _Copy(a, b, 5);
}
//特化自定义类型
void test2()
{
    string a[5] = { "abc", "def", "ghi", "123", "456" };
    string b[4] = {"111111111111111111111111111111111111111", "222222", "333333", "44444444"};
    _Copy(a, b, 3);
}
int main()
{
    //test1();
    test2();
    system("pause");
    return 0;
}

简单调用关系图如下：

图片地址：https://blog.csdn.net/ling_hun_pang_zi/article/details/79827939

类型萃取有什么用？
型萃取一般用于模板中，当我们定义一个模板函数后，
需要知道模板类型形参并加以运用时就可以用类型萃取。
比如我们需要在函数中进行拷贝，通常我们可以用内置函数memcpy或者自己写一个for循环来进行拷贝。比如：

template<typename T>
void Copy(T *dest, const T *src, size_t sz)
{
if (_TypeTraits<T>::_IsPODType().Get())
{
cout << "内置类型用memcpy函数进行拷贝：" << endl;
memcpy(dest, src, sz * sizeof(T));
}
else
{
cout << "自定义类型用for循环进行拷贝：" << endl;
for (size_t i = 0; i < sz; i++)
{
*(dest + i) = *(src + i);
}
}
}

这是一个通用的拷贝函数，可以拷贝多种类型的数据，比如内置类型的int、double等和自定义结构体或类类型。我们可以看到其中用了两种拷贝方式—memcpy和for循环，为什么这里要用两种拷贝方式呢？ 我们知道memcpy进行拷贝时效率很高，但是它是将所拷贝对象中的值全部原样地复制到目标对象中去，那么如果我们在对带指针的自定义对象进行拷贝时就会把源对象指针值拷贝到目标对象内指针内去，这样就造成了多个对象的指针指向同一块内存，这样就成了浅拷贝了。这里为了避免浅拷贝的发生就特意用效率相对较低的for循环来对自定义类型的对象进行拷贝工作。因此这个拷贝函数里面就给出了两种拷贝方式。 搞清楚了为什么要用两种拷贝方式，那么重点来了—怎么分辨需要拷贝的对象是内置类型还是自定义类型呢？方法有很多，比如我们可以在一个函数里面罗列出各种内置类型，将模板函数的类型形参T满足传入这个函数，当满足罗列出的类型时就用返回一个true否则返回false。这是一种方法，但是这里我们给出另一种方法—类型萃取。

类型萃取解析
先给出代码：

struct _TrueType
{
bool Get()
{
return true;
}
};
struct _FalseType
{
bool Get()
{
return false;
}
};
template<typename T>
struct _TypeTraits
{
typedef _FalseType _IsPODType;
};
template<>
struct _TypeTraits<int>
{
typedef _TrueType _IsPODType;
};

解析：这里给出了四个结构体（ps：结构体默认访问类型为public比默认类型为private的类方便），前两个结构体一个为_TrueType表示内置类型，一个为_FalseType表示自定义类型，两个结构体内都定义了一个返回类型为bool类型的函数Get()，其中一个返回true一个返回false。第三个为结构体模板，模板内将结构体类型_FalseType重定义为_IsPODType（ps：在类或者结构体内对类型重定义后，重定义的类型属于这个类或结构体的成员类型，其作用域在这个类或结构体里面），当我们用这个结构体内的_IsPODType类型定义一个对象来调用函数Get()时就会返回一个false，表示T类型为自定义类型。第四个结构体是对第三个结构体模板的特化，这里特化成为int类型，当然也可以特化为double或者char类型，这个结构体里面将结构体类型_TrueType重定义为_IsPODType,当传入的参数为int类型时用_IsPODType定义对象就可以调用_TrueType结构体内的Get函数，返回一个true，表示传入了内置类型。
进行测试：对这段代码作了解释后，来结合上面的Copy函数运行一下，看能不能对内置类型和自定义类型的参数执行不同的拷贝方式。我们先调用Copy函数拷贝内置类型：

int main()
{     
    //首先进行内置类型的拷贝     
    int array1[10] = { 0,1,2,3,4,5,6,7,8,9 };     
    const size_t size = sizeof(array1) / sizeof(array1[0]);     
    int array2[size] = { 1,2,3 };     
    Copy(array2, array1, size);     
    for (size_t i = 0; i < size; i++)
    {   
        cout << array2[i] << " ";
    }     
    cout << endl; 
    return 0;
}

用模板萃取出类型。

原文地址：https://blog.csdn.net/ling_hun_pang_zi/article/details/79827939