类型萃取

类型萃取是实现不同类型数据面对同一函数实现不同的操作，它与类封装的区别是：并不用知道所调用的对象是什么类型，类型萃取是编译后知道类型，先实现；而类的封装则是先定义类型，后实现方法。
类型分为基本类型（POD），和自定义类型。
在这里用模板的特化实现其编程思想：
以memcpy为例，当拷贝的是基本类型（POD）时，只用拷贝所传递指针上的数据，如果是string类型，则需要在堆上开辟空间，所传递的指针如果被直接复制，则有可能（vs下的string类型的实现原理是若字符串不长则以数组保存，若字符串过长，则通过指针在堆上开辟空间进行保存）出现同一地址，析构两次，出现错误。
程序：

#include<iostream>
using namespace std;
#include<string>

struct __TrueType
{
static bool Get()
{
return true;
}
};

struct __FalseType
{
static bool Get()
{
return false;
}
};

template <class T>
struct TypeTraits//traits为特性
{
typedef __FalseType __IsPODType;
};

template <>
struct TypeTraits< bool>
{
typedef __TrueType __IsPODType;
};

template <>
struct TypeTraits< char>
{
typedef __TrueType __IsPODType;
};

template <>
struct TypeTraits< unsigned char >
{
typedef __TrueType __IsPODType;
};

template <>
struct TypeTraits< short>
{
typedef __TrueType __IsPODType;
};

template <>
struct TypeTraits< unsigned short >
{
typedef __TrueType __IsPODType;
};

template <>
struct TypeTraits<int>
{
typedef __TrueType __IsPODType;
};

template<class T>
void _Memcpy(T& dest, const T& src, size_t size, __TrueType) //基本类型
{
cout << "IsPOD::" << typeid(T).name() << endl;
memcpy(dest, src, sizeof(T)*size);
}

template<class T>
void _Memcpy(T& dest, const T& src, size_t size, __FalseType)
{
cout << "IsNotPOD::" << typeid(T).name() << endl;
for (int i = 0; i < size; i++)
{
dest[i] = src[i];
}
}

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

SeqList<T>(const SeqList<T>& s)
{
_array = new T[s._size];
if (TypeTraits <T>::__IsPODType().Get())
{
_Memcpy(_array, s._array, s._size, TypeTraits<T>::__IsPODType());
}
else
{
_Memcpy(_array, s._array, s._size, TypeTraits<T>::__IsPODType());
}
swap(_size, s._size);
swap(_capacity, s._capacity);
}

SeqList<T>& operator= (SeqList<T> s)
{
swap(_array, s._array);
swap(_size, s._size);
swap(_capacity, s._capacity);
}

~SeqList()
{
if (_array)
{
delete[] _array;
_array = NULL;
}
}

void _CheckCapacity(size_t n)
{
if (n > _capacity)
{
_capacity = 2 * _capacity + 3;
T* tmp = new T[_capacity];
if (_array != NULL)
{
if (TypeTraits <T>::__IsPODType().Get())
{
_Memcpy(tmp, _array, _size, TypeTraits <T>::__IsPODType());
}
else
{
_Memcpy(tmp, _array, _size, TypeTraits <T>::__IsPODType());
}
}
delete[] _array;
_array = NULL;
_array = tmp;
}
}

void PushBack(const T& x);//尾插
void PopBack();//尾出
void PrintSeqList();//打印链表

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

template<class T>
void SeqList<T>::PushBack(const T& x)
{
_CheckCapacity(_size + 1);
_array[_size++] = x;
}

template<class T>
void SeqList<T>::PopBack()
{
if (_size == 0)
{
return;
}
else
{
--_size;
}
}

template<class T>
void SeqList<T>::PrintSeqList()
{
for (int i = 0; i < _size; i++)
{
cout << _array[i] << " ";
}
cout << endl;
}

//int的测试函数
//void Test()
//{
// SeqList<int> s1;
// s1.PushBack(1);
// s1.PushBack(2);
// s1.PushBack(3);
// s1.PushBack(4);
// s1.PushBack(5);
// s1.PrintSeqList();
// s1.PrintSeqList();
//}

//string的测试函数
void Test()
{
SeqList<string> s2;
s2.PushBack("Hello");
s2.PushBack("yaoyao! ");
s2.PrintSeqList();
s2.PrintSeqList();
}

int main()
{
Test();
system("pause");
return 0;
}
运行结果：
Hello yaoyao!
Hello yaoyao!
请按任意键继续. . .