C++中的浅拷贝与深拷贝

用自定义的String类解释什么是浅拷贝什么是深拷贝。

class String 
{ 
private: 
 char* _str; 
};

浅拷贝是在调用拷贝函数时进行了值拷贝，这样的拷贝看似没有问题，在调用析构函数时会导致内存泄漏，系统奔溃。

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class String
{
public:
	String(const char*str="")
		:_str(new char[strlen(str) + 1])
	{
		strcpy(_str, str);
		cout << "String" << endl;
	}
	~String()
	{
		if (_str)
		{
			delete[]_str;
			cout << "~String" << endl;
		}
	}
	char *Getstr()
	{
		return _str;
	}
private:
	char*_str;
};
void TestString()
{
	String s1("hello world!");
	String s2;
	String s3(s1);
	//String s2 = s1;
	cout << s1.Getstr() << endl;
	cout << s3.Getstr() << endl;

}
int main()
{
	TestString();
	system("pause");
	return 0;
}

我们自己编写了构造函数和析构函数，在运行测试用例时出现系统奔溃：

是因为在String s3（s1）时系统调用默认拷贝构造即“浅拷贝”。

所以我们要自己编写拷贝构造与赋值运算符重载，进行深拷贝。

深拷贝是指在拷贝构造时，新开辟一块空间，将_str指向的内容拷贝到这块新的空间里，再将自己的_str指向这块空间。下面是代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class String
{
public:
	String(const char*str="")
		:_str(new char[strlen(str) + 1])
	{
		strcpy(_str, str);
		cout << "String" << endl;
	}
	~String()
	{
		if (_str)
		{
			delete[]_str;
			cout << "~String" << endl;
		}
	}
	String(const String& d)
	{
		this->_str = new char[strlen(d._str) + 1];   //this可以省略，+1是因为字符串后还有‘\0’
		strcpy(_str, d._str);
	}

	String& operator=(const String& d)
	{
		if (this != &d)
		{
			delete[]_str;          //首先释放自己空间
			_str = new char[strlen(d._str) + 1];
			strcpy(_str, d._str);
		}
		return *this;
	}
	char *Getstr()
	{
		return _str;
	}
private:
	char*_str;
};
void TestString()
{
	String s1("hello world!");
	String s2;
	String s3(s1);
    s2 = s1;
	cout << s1.Getstr() << endl;
	cout << s3.Getstr() << endl;
	cout << s2.Getstr() << endl;
}

运行结果为：

深拷贝有两种写法，第一种是传统写法，就是我上面这种写法，老老实实开辟新空间，老老实实拷贝字符串；

还有一种是现代写法，相对于传统写法更简洁一点，是让别人开空间拷贝字符串，再将别人的空间与自己交换，坐享渔翁之利。

代码如下：

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;
class String
{
public:
	String(const char*str="")
		:_str(new char[strlen(str) + 1])
	{
		strcpy(_str, str);
		cout << "String" << endl;
	}
	~String()
	{
		if (_str)
		{
			delete[]_str;
			cout << "~String" << endl;
		}
	}
	String(const String& d)
		:_str(NULL)               //如果tmp置空可以避免释放野指针        
	{
		String tmp(d._str);        //让临时对象tmp去构造与d._str相同的空间，再将tmp与自己交换
		swap(_str, tmp._str);
	}

	String& operator=(const String& d)
	{
		if (this != &d)
		{
			String tmp(d._str);       //赋值首先要做的是释放自己的空间，然后创建一块新空间，赋值为其他对象成员变量
			swap(_str, tmp._str);     //现代写法可以减少释放自己空间这一步骤，因为临时对象tmp在函数调用后自动释放
		}
		return *this;
	}
	char *Getstr()
	{
		return _str;
	}
private:
	char*_str;
};
void TestString()
{
	String s1("hello world!");
	String s2;
	String s3(s1);
    s2 = s1;
	cout << s1.Getstr() << endl;
	cout << s3.Getstr() << endl;
	cout << s2.Getstr() << endl;


}
int main()
{
	TestString();
	system("pause");
	return 0;
}

现代写法中的赋值运算符重载也可以使用对象参数，上面使用的是引用。

String& operator=(String s)
	{
		swap(_str, s._str);
		return *this;
	}

在这种写法中，因为参数是一个临时变量，所以在调用赋值函数时String s就是对象的临时拷贝，可以直接交换，

String s因为是临时变量，在出了作用域后自动销毁，不用自己调用delete函数。