c++:模板的类型萃取

首先，需要举一个例子来说明c++在什么情况下需要对不同的类型不同对待。

template <class T>
class SeqList
{
public:
    SeqList()
        :_a(NULL)
        , _size(0)
        , _capacity(0)
    {}

    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            _capacity = _capacity > 0 ? _capacity * 2 : 3;//当容量为0时增容为3，之后每次增2倍
            T* newA = new T[_capacity];
            if (_a != NULL)
            {
                memcpy(newA, _a, _size*sizeof(T));//使用memcpy
            }
            delete[] _a;
            _a = newA;

        }
    }

    void PushBack(const T& x)
    {
        CheckCapacity();
        _a[_size++] = x;
    }

    void Print()
    {
        for (size_t i = 0; i < _size; i++)
        {
            cout << _a[i] << " ";
        }
        cout << endl;
    }

private:
    T* _a;
    size_t _size;
    size_t _capacity;
};

这是一个模板类的顺序表，实现了尾插和增容两个接口。
接下来进行测试：

void TestSeqList()
{
    SeqList<int> s1;
    s1.PushBack(1);
    s1.PushBack(2);
    s1.PushBack(3);
    s1.PushBack(4);
    s1.Print();
}

它是没有问题的：

但是如果里面存string类型：

可以看到，它崩溃了，而且打印出来了数据，说明是在析构的时候崩溃，到底怎么回事？

如图，因为使用得是memcpy，所以新开辟的空间的前三个_str和_a指向的空间的每一个_str指向的一样。
这样就导致delete[] _a的时候，新开辟的空间的前三个_str为野指针，必然崩溃。
如果需要解决问题，只要这样做：

                for (size_t i = 0; i < _size; i++)
                {
                    newA[i] = _a[i];
                }

利用operator=，通过for循环依次赋值，这样新旧_str指向的空间不同，解决了问题。

现在就出现了需要对不同的类型不同对待的情况，因为memcpy的效率比for循环高得多，但是对特殊类型又不得不使用for循环。
使用全特化可以解决:

template <>
class SeqList<int>
{
public:
    SeqList()
        :_a(NULL)
        , _size(0)
        , _capacity(0)
    {}

    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            _capacity = _capacity > 0 ? _capacity * 2 : 3;
            int* newA = new int[_capacity];
            if (_a)
            {
                memcpy(newA, _a, _size*sizeof(int));
            }
            delete[] _a;
            _a = newA;
        }
    }

    void PushBack(const int& x)
    {
        CheckCapacity();
        _a[_size++] = x;
    }


~SeqList()
{
    delete[] _a;
    _size = _capacity = 0;
}

private:
    int* _a;
    size_t _size;
    size_t _capacity;
};

template <>
class SeqList<string>
{
public:
    SeqList()
        :_a(NULL)
        , _size(0)
        , _capacity(0)
    {}

    void CheckCapacity()
    {
        if (_size >= _capacity)
        {
            _capacity = _capacity > 0 ? _capacity * 2 : 3;
            string* newA = new string[_capacity];
            if (_a)
            {
                for (size_t i = 0; i < _size; i++)
                {
                    newA[i] = _a[i];
                }
                delete[] _a;
            }
            _a = newA;
        }
    }

    void PushBack(const string& x)
    {
        CheckCapacity();
        _a[_size++] = x;
    }

    ~SeqList()
    {
        delete[] _a;
        _size = _capacity = 0;
    }

private:
    string* _a;
    size_t _size;
    size_t _capacity;
};

这不是一个好办法，这样做会让代码的复用性很差，全是重复代码。
现在就该类型萃取出场了：

struct __TrueType//一个空类
{};

struct __FalseType//空类
{};

template <class T>
struct __TypeTraits
{
    typedef __FalseType ISPODType; //默认为不是基本类型 POD（基本类型）
};

template <>
struct __TypeTraits<int>
{
    typedef __TrueType ISPODType; //int是基本类型
};

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,__TrueType)
{
    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)
{
    for (size_t i = 0; i < n; i++)
    {
        dst[i] = src[i];
    }
    cout << "operator=()" << endl;
    return dst;
}

想要读懂这段代码不容易，我总结一下：


通过TypeCopy，那么就可以根据类型来确定拷贝方案。