深拷贝和浅拷贝

C++中一个非常经典的问题就是深拷贝和浅拷贝的问题，这属于拷贝构造函数中的内容。浅拷贝时，拷贝类的对象时，将拷贝其指针成员，但是没有复制指针指向的缓冲区，这样做的结果就是，两个对象指向同一块动态分配的内存。浅拷贝会威胁程序的稳定性。这样说起来可能不太好理解，下面给出一个很好的例子，自定义一个类似string的MyString类如下：

#include <iostream>
#pragma warning(disable:4996)
using namespace std;
class MyString
{
private:
	char* m_buffer;

public:
	MyString(const char* input)
	{
		if (input != NULL)
		{
			m_buffer = new char[strlen(input) + 1];
			strcpy(m_buffer, input);
		}
		else
			m_buffer = NULL;
	}
	~MyString()
	{
		cout << "Invoking destructor!" << endl;
		if (m_buffer != NULL)
			delete m_buffer;
	}
	int GetLength()
	{
		return strlen(m_buffer);
	}
	const char* GetString()
	{
		return m_buffer;
	}
};
void TestMyString(MyString Input)
{
	cout << "The length of string buffer in MyString is " << Input.GetLength() << endl;
	cout << "Buffer contains " << Input.GetString() << endl;
	return;
}

int main()
{
	MyString strTest("String from the String Class");
	TestMyString(strTest);
	return 0;
}

在类中定义了MyString的构造函数和析构函数，以及一个测试函数TestMyString，程序的运行结果如下：

直接崩了，仔细分析一下，其实崩了也正常。因为TestMyString(strTest);这一行代码使得对象strTest被拷贝到形参Input，并在TestMyString中使用它。之所以会这样，因为函数TestMyString的参数Input被声明为按值传递，而不是按引用传递。对于整型、字符和原始指针等POD数据，编译器会执行二进制复制。所以，strTest.m_buffer包含的指针被拷贝到Input中，即strTest.m_buffer和Input.m_buffer指向同一个内存单元，如下图所示：

二进制复制并不深复制指向的内存单元，这导致两个MyString对象指向同一个内存单元。函数TestMyString返回时，变量Input不在作用域内，所以会调用构造函数销毁，即调用MyString的析构函数，该析构函数会利用delete释放分配给m_buffer指针指向的内存，这样做的结果是对象strTest指向的内存无效，所以等到main()执行完毕后，MyString类的对象strTest不再在main的作用域内，也会调用析构函数，直接导致不再有效地内存地址调用delete，所以程序崩了。

解决这一问题的有效方式就是利用拷贝构造函数。拷贝构造函数是一个特殊的重载构造函数，每当对象被拷贝时，包括将对象按值传递给函数时，编译器都将调用拷贝构造函数。拷贝构造函数可以接受一个以引用方式传入的当前类的对象作为参数。这个参数是源对象的别名，可以利用它来编写自定义的拷贝，以确保对所有的缓冲区进行深拷贝。所以上面的代码可以修改如下：

#include <iostream>
#pragma warning(disable:4996)
using namespace std;

class MyString
{
private:
	char* m_buffer;

public:
	MyString(const char* input)
	{
		if (input != NULL)
		{
			m_buffer = new char[strlen(input) + 1];
			strcpy(m_buffer, input);
		}
		else
			m_buffer = NULL;
	}
	//拷贝构造函数
	MyString(const MyString& res)
	{
		cout << "Copy Constructor:copy from MyString" << endl;
		if (res.m_buffer != NULL)
		{
			m_buffer = new char[strlen(res.m_buffer) + 1];
			strcpy(m_buffer, res.m_buffer);
		}
		else
			m_buffer = NULL;
	}
	~MyString()
	{
		cout << "Invoking destructor!" << endl;
		if (m_buffer != NULL)
			delete m_buffer;
	}
	int GetLength()
	{
		return strlen(m_buffer);
	}
	const char* GetString()
	{
		return m_buffer;
	}
};
void TestMyString(MyString Input)
{
	cout << "The length of string buffer in MyString is " << Input.GetLength() << endl;
	cout << "Buffer contains " << Input.GetString() << endl;
	return;
}

int main()
{
	MyString strTest("String from the String Class");
	TestMyString(strTest);
	return 0;
}

这里仅仅添加了一个拷贝构造函数：

MyString(const MyString& res)
	{
		cout << "Copy Constructor:copy from MyString" << endl;
		if (res.m_buffer != NULL)
		{
			m_buffer = new char[strlen(res.m_buffer) + 1];
			strcpy(m_buffer, res.m_buffer);
		}
		else
			m_buffer = NULL;
	}

程序的执行结果如下：

在main中，将strTest按值传递给函数TestMyString的时候，将自动调用拷贝构造函数。这里并非是浅拷贝，仅仅复制指针的值，而是进行了深拷贝，即将指向的内容拷贝到给当前对象新分配的缓冲区中，如下图所示：

拷贝中的m_buffer指向内存地址不同，即两个对象并没有指向同一个动态分配的内存地址。所以，函数TestMyString返回，形参Input被销毁时，析构函数对拷贝构造函数分配的内存地址调用delete[]，而没有影响在main函数中strTest指向的内存。所以这两个函数执行结束后，成功地销毁了各自的对象，没有导致程序崩溃。

上面的程序还有个问题就是，拷贝构造函数确实可以确保函数调用可以进行深拷贝，但是当通过赋值进行拷贝时，比如说：

MyString strTest01("Test");

strTest01 = strTest;

由于没有指定任何的赋值运算符，所以编译器提供的默认赋值运算符将导致浅拷贝。为避免赋值时进行钱拷贝，还需要实现赋值运算符。

MyString &operator=(const MyString&other);//赋值函数

参考之前的一篇博客：C++String类的构造函数、拷贝构造函数的实现

当类中包含原始指针成员时，需要编写拷贝构造函数和拷贝赋值运算符的代码。一般写代码中会把类成员声明成std::string和智能指针类，而不是原始指针。因为它们已经实现了拷贝构造函数，这样就不需要自己写拷贝构造函数了。所以，如果类的数据成员是设计良好的智能指针、字符串类或者STL容器，则编译器生成的默认拷贝构造函数将调用成员的拷贝构造函数。

在C++11中，还有一个有助于改善性能的移动构造函数。在某些情况下，对象会自动被拷贝。再给个例子，同样是基于MyString类，添加如下函数：

MyString Copy(MyString& res)
{
	MyString copyRet(res.GetString());
	return copyRet;
}

在main中测试如下：

int main()
{
	MyString strTest("String from the String Class");
	//TestMyString(strTest);
	MyString strTest01(Copy(strTest));
	return 0;
}

运行结果如下：

实例化strTest01时，由于调用了函数Copy(strTest)，它按值返回一个MyString，因此调用了拷贝构造函数两次。但是，这个返回值的存在时间很短，而且在表达式外不可用。所以，C++编译器严格地执行拷贝构造函数反而降低了性能，如果拷贝的是很大的动态对象数组，对性能的影响更加明显。所以，为了避免上面的性能瓶颈，除了编写拷贝构造函数以外，还需要写一个移动构造函数。移动构造函数的实现如下：

<span style="white-space:pre">	</span>MyString(MyString& moveRes)
	{
		if (moveRes.m_buffer!=NULL)
		{
			m_buffer = moveRes.m_buffer;
			moveRes.m_buffer = NULL;
		}
	}

有了移动构造函数以后，C++11编译器将自动地利用移动构造函数来“移动”临时的资源，从而避免深拷贝。移动构造函数通常是利用移动赋值运算符实现的。

VS2013还不完全支持C++11。

https://msdn.microsoft.com/zh-cn/library/hh567368.aspx#featurelist