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

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

  下面我们可以通过一个简单的顺序表程序来分析memcpy对非内置类型所产生的副作用：

#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;
};

上面是一个简单的顺序表的模版，当我们将上模板中的拷贝构造，赋值重载和容量检测都用memcpy实现时，并且我们给出下面的测试主函数（此时我们使用的是内置类型）：

int main()
{
	SeqList<int> s;
	s.Pushback(1);
	s.Pushback(2);
	s.Pushback(3);
	s.Pushback(4);
	s.Print();
	SeqList<int> s3(s);
	s.Print();
	SeqList<int> s2;
	s2 = s;
	s2.Print();
	system("pause");
	return 0;
}

下面是运行结果：

此时程序并没有出现异常，而当我们将其测试主函数改为string时,如下：

int main()
{
	SeqList<string> s;
	s.Pushback("111");
	s.Pushback("222");
	s.Pushback("333");
	s.Pushback("444");
	s.Print();
	SeqList<string> s3(s);
	s.Print();
	SeqList<string> s2;
	s2 = s;
	s2.Print();
	system("pause");
	return 0;
}

此时出现的情况是：

没错！ 程序崩溃了！

而且不论你使用上述三个成员函数中任意一memcpy，程序都会崩溃！

由于我使用的是VS2013；程序崩溃后的光标时打到析构函数处，因此比较容易想到是出现了浅拷贝的状况（由于不同版本编译器会出现不同的状况，所以此文的分析是在VS2013这个版本基础上建立的）

  下面就以容量检测这个成员函数为例进行一个具体的分析，当我们进行尾插时，只有当我们插入的数据超过_capacity,才会进行增容处理，因为我给的初始容量是三个，所以当进行第四个插入时才会进入到增容函数中去，下图就是当进入到增容函数中后出现的状况：

可以看见当进去后执行完memcpy后，_data所指向的是一个地址，而当我把这个地址拿到后发现一个很神奇的现象，这个地址放的竟然是它：

没错，是_data的地址！

然后我又看了tmp的地址，如下图：

到这里基本上就清楚了，tmp和_data是指向了同一份地址，而这个地址又是_data的，因此在上面的大图中，当_data被释放掉时，tmp里面还是_data的地址，是一个已经被释放的空间地址，而在析构函数中你又释放了一次，因此程序会在析构处崩溃，这也是memcpy所带来的副作用——浅拷贝现象！

  而当你将下面的for循环放开，然后将memcpy注释掉，问题就解决了，在这是因为这里用的是string的operator=进行的赋值操作。

  这里还要说明的一点是，因为不同版本编译器对string的构造并不一样，因此我才一直在强调编译的环境，可能其他的版本出现的现象并不一样，但其原理是没有改变的！因此在以后的类模版中我们要尽量避免使用memcpy。

  本文若有不足之处，请读者在留言之处提醒，谢谢！