【深入理解C++】浅拷贝与深拷贝

1.前置知识

#include <iostream>
using namespace std;

class Car
{
private:
	int m_price;
	char* m_name;
public:
	Car(int price = 0, char* name = NULL) : m_price(price), m_name(name)
	{
		cout << "调用了Car的构造函数" << endl;
	}
	void display()
	{
		cout << "price is " << m_price << ", name is " << m_name << endl;
	}
};

int main()
{
	char name[] = { 'b', 'm', 'w', '\0' };

	Car* car = new Car(100, name);
	
	car->display();

	return 0;
}

上面代码的内存分配如下图所示：

堆空间指向栈空间是一件危险的事情！我们可以将 name 数组中的内容拷贝到堆空间，这样就实现了堆空间指向堆空间。

#include <iostream>
using namespace std;

class Car
{
private:
	int m_price;
	char* m_name;
public:
	Car(int price = 0, const char* name = NULL) : m_price(price)
	{
		if (name == NULL) return;
		// 申请新的堆空间
		m_name = new char[strlen(name) + 1] {};
		// 拷贝字符串数据到新的堆空间
		strcpy(m_name, name);
	}

	~Car()
	{
		if (m_name == NULL) return;

		delete[] m_name;
		m_name = NULL;
	}

	void display()
	{
		cout << "price is " << m_price << ", name is " << m_name << endl;
	}
};

int main()
{
	char name[] = { 'b', 'm', 'w', '\0' };

	Car* car = new Car(100, name);

	car->display();

	return 0;
}

2.浅拷贝

编译器默认提供的拷贝是浅拷贝（shallow copy），将一个对象中所有成员变量的值拷贝到另一个对象，如果某个成员变量是个指针，只会拷贝指针中存储的地址值，并不会拷贝指针指向的内存空间，可能会导致堆空间多次 free 的问题。

#include <iostream>
using namespace std;

class Car
{
private:
	int m_price;
	char* m_name;
public:
	Car(int price = 0, const char* name = NULL) : m_price(price)
	{
		if (name == NULL) return;
		// 申请新的堆空间
		m_name = new char[strlen(name) + 1] {};
		// 拷贝字符串数据到新的堆空间
		strcpy(m_name, name);
	}

	~Car()
	{
		if (m_name == NULL) return;

		delete[] m_name;
		m_name = NULL;
	}

	void display()
	{
		cout << "price is " << m_price << ", name is " << m_name << endl;
	}
};

int main()
{
	Car car1(100, "bmw");
	Car car2 = car1;
	car2.display();

	return 0;
}

3.深拷贝

深拷贝（deep copy）是将指针类型的成员变量所指向的内存空间拷贝到新的内存空间。如果需要实现深拷贝，就需要自定义拷贝构造函数。

#include <iostream>
using namespace std;

class Car
{
private:
	int m_price;
	char* m_name;
public:
	Car(int price = 0, const char* name = NULL) : m_price(price)
	{
		if (name == NULL) return;
		// 申请新的堆空间
		m_name = new char[strlen(name) + 1] {};
		// 拷贝字符串数据到新的堆空间
		strcpy(m_name, name);
	}

	Car(const Car& car) : m_price(car.m_price)
	{
		if (car.m_name == NULL) return;
		// 申请新的堆空间
		m_name = new char[strlen(car.m_name) + 1] {};
		// 拷贝字符串数据到新的堆空间
		strcpy(m_name, car.m_name);
	}

	~Car()
	{
		if (m_name == NULL) return;

		delete[] m_name;
		m_name = NULL;
	}

	void display()
	{
		cout << "price is " << m_price << ", name is " << m_name << endl;
	}
};

int main()
{
	Car car1(100, "bmw");
	Car car2 = car1;
	car2.display();

	return 0;
}

4.总结

通常，默认生成的拷贝构造函数和拷贝赋值运算符只是简单地进行值的复制。

如果一个类的字段全是 int 这种基本数据类型，那么拷贝构造函数创建出来的对象和源对象是没有任何关联的，对源对象的任何操作都不会影响到拷贝出来的对象。

如果一个类的字段有 int * 这种指针类型，这时在拷贝时还只是进行值复制，那么创建出来的对象的 int * 就和源对象的 int * 指向的是同一个位置。任何一个对象对该值的修改都会影响到另一个对象，这种情况就是浅拷贝。

深拷贝和浅拷贝主要是针对类中的指针和动态分配的空间来说的，因为对于指针只是简单的值复制并不能分割开两个对象的关联，任何一个对象对该指针的操作都会影响到另一个对象。这时候就需要提供自定义的深拷贝的拷贝构造函数，消除这种影响。

通常的原则是：

• 含有指针类型的成员或者有动态分配内存的成员都应该提供自定义的拷贝构造函数
• 在提供拷贝构造函数的同时，还应该考虑实现自定义的拷贝赋值运算符

对于拷贝构造函数的实现要确保以下几点：

• 对于值类型的成员进行值复制
• 对于指针和动态分配的空间，在拷贝中应重新分配空间
• 对于基类，要调用基类合适的拷贝方法，完成基类的拷贝