模板的类型萃取

分析类型萃取问题
功能:
类型萃取，在STL中用到的比较多，用于判断一个变量是否为POD（plain old data,平凡类型）类型。
简单来说可以用来判断出某个变量是内置类型还是自定义类型。
通过类型萃取，萃取到变量类型，对不同变量进行不同处理，可以提升程序效率。
应用场景：
例如实现顺序表，在对顺序表进行扩容时，利用类型萃取，重新开辟内存、拷贝对象。
拷贝对象时，分两种情况：1）内置类型，如int、char……；2）自定义类型，如Date类、SeqList类。
对于内置类型，可通过memcpy函数进行拷贝，此时进行的是浅拷贝。
而，对于自定义类型，大多数需要深拷贝的对象来说，必须调用赋值语句来赋值。
因此，在拷贝对象时，为不出错，通常用赋值语句来赋值。但缺点是效率较低。
通过类型萃取判断POD类或非POD类，对于POD类用浅拷贝，memcpy函数，对于非POD类用深拷贝，进行赋 值，这样就可以提高程序效率。
实现：
类型萃取，在技术层面，就是利用了模板的特化。
下面举例说明：

template<class T>
void SeqList::CheckCapacity()
{
     _capacity=_capacity>0?_capacity*2:3;
     T* tmp=new T[_capacity];
     if(_a)
     {
          memecpy(tmp,_a,sizof(T)*_size);
          delete[] _a;
     }
     _a=tmp;
 }

代码中，当T为内置类型时，可以正常运行，但当T为自定义类型时会出错，原因是memcpy是浅拷贝，自定义类型中如果有指针，当扩容前存了指针ptr进去，使用CheckCapacity()扩容时，delete[] _a会清理释放ptr指向的内容，当使用memcpy函数进行浅拷贝后，扩容后的ptr为野指针，当程序执行结束时会调用析构函数，那么将会对同一块空间析构两次。


类型萃取的代码如下：

template<class T>
struct _TypeTraits
{
    //POD——基本类型，指在C++中与C兼容的类型，可以按照C的方式处理。
    typedef _FalseType IsPODType;
};
template<>
struct _TypeTraits<int>//特化
{
    typedef _TrueType IsPODType;
};

template<class T>
T* TypeCopy(T* dst, const T* src, size_t n)
{
    return _TypeCopy(dst, src, n, _TypeTraits<T>::IsPODType());
};
template<class T>
T* _TypeCopy(T* dst, const T* src, size_t n, _FalseType)
{
    T* Dst = dst;
    for (size_t i = 0; i<n; ++i)
    {
        dst[i] = src[i];
    }
    return Dst;
};
template<class T>
T* _TypeCopy(T* dst, const T* src, size_t n, _TrueType)
{
    return (T*)memcpy(dst, src, n*sizeof(T));
};

测试代码如下：

void Test()
{
    int a1[3] = { 1, 2, 3 };
    int a2[3];
    char s1[]="aabbcc";
    char s2[7]; 
    TypeCopy(a2, a1, 3);
    TypeCopy(s2, s1, 7);
    for (size_t i = 0; i<3; ++i)
    {
        cout << a2[i] << " ";
    }
    cout << endl;
    for (size_t i = 0; i<7; ++i)
    {
        cout << s2[i] << " ";
    }
    cout << endl;
}
int main()
{
    Test();
    system("pause");
    return 0;
}

运行结果：

分析图如下：