浅析在类模版中构建成员函数时，使用memcpy产生的副作用

  一般情况下我们在对类模版中的成员函数进行构建时会经常对一些数据进行复制拷贝，而通常情况下我们都不提倡用memcpy进行拷贝，因为在类模版中所传进来的类型可以是内置类型也可以是非内置类型，除非你在成员函数中使用memcpy前进行类型萃取，否则它所带来的副作用的后果也是很可怕的。memcpy在对内置类型可正常拷贝，而在对非内置类型拷贝时会出现浅拷贝的现象。

  下面我们可以通过一个简单的顺序表程序来分析memcpy对非内置类型所产生的副作用：
[code=cpp;toolbar:false">#include<iostream>
#include<string>
using namespace std;

template<typename T>
class SeqList
{
public:
SeqList()                        //构造函数
:_data(NULL)
, _size(0)
, _capacity(0)
{}
SeqList<T>& operator=(const SeqList<T>& s)           //赋值重载
{
if (this != &s)
{

_data = new T[s._capacity];
_size = s._size;
_capacity=s._capacity;
memcpy(_data, s._data, _size*sizeof(T));
/*int i=0;
for (i = 0; i < _size; i++)
{
_data[i] = s._data[i];
}*/
}
return *this;
}
SeqList(const SeqList<T>& s)                       //拷贝构造
:_data(new T[s._capacity])
, _size(s._size)
, _capacity(s._capacity)
{
        memcpy(_data, s._data, _size*sizeof(T));
/*int i = 0;
for (i = 0; i < _size; i++)
{
_data[i] = s._data[i];
}*/
}
~SeqList()                                            //析构函数
{
if (_data != NULL)
{
delete[] _data;
_size = 0;
_capacity = 0;
}

}
public:
void Pushback(const T& d)
{
CheckCapacity();
_data[_size] = d;
_size++;
}

public:
void CheckCapacity()                 //容量检测
{
if (_size == _capacity)
{
T *tmp = new T[2 * _capacity + 3];
memcpy(tmp, _data, _size*sizeof(T));
/*int i = 0;
for (i = 0; i < _size; i++)
{
tmp[i] = _data[i];
}*/
delete[] _data;
_data = tmp;
_capacity = 2 * _capacity + 3;
}
}
void Print()
{
int i = 0;
for (; i < _size; i++)
{
cout << _data[i] << " ";
}
cout << endl;
}
private:
T*_data;
int _size;
int _capacity;
};