c++浅拷贝与深拷贝

先看下面这份代码

class String
{
public:
	String(const char* str="")
	{
		//构造string类对象，如果传递nullptr指针，认为程序非法，此处断言下
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str)+1];
		strcpy(_str, str);
	}
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

void TestString()
{
	String s1("hello world!!");
	String s2(s1);
}

上面代码简单模拟实现string类,但是有问题，首先s1调用String类的构造函数，再是s2调用String类拷贝构造函数来创建，该类没有显式定义，则使用系统合成的默认拷贝构造函数，此时s1与s2共有一块空间，TestString函数结束时，需要将s1与s2销毁掉，假设先销毁s2，s2，将其_str所指的空间释放掉，s2对象成功销毁，但是s1中_str成为野指针，当s1销毁时出错。

上述String类没有显示定义拷贝构造函数与赋值运算符重载，此时编译器会合成默认的，当用s1构造s2时，编译器会调用默认的拷贝。最终导致的问题是，s1，s2共用同一块内存空间，在释放时同一块空间被释放多次而引起程序崩溃，这种拷贝方式，称为浅拷贝。

浅拷贝：也称位拷贝，编译器只是将对象中的值拷贝过来。如果对象中管理资源，最后就是导致多个对象共享一份资源，当一个对象销毁时就会将该资源释放掉，而此时另一些对象不知道该资源已经被释放，以为还有效，所以当继续对资源进行操作时，就会发送了访问违规。

如果一个类中涉及到资源的管理，其拷贝构造函数，赋值运算符重载以及析构函数必须要显式给出。一般情况都是按照深拷贝方式提供。
深拷贝：给每个对象独立分配资源，保证多个对象之间不会因为共享资源而造成多次释放造成程序崩溃问题。

#include<iostream>
#include<cstring>
#include<string>
#include<assert.h>
using namespace std;
//传统写法的String类
class String{
public:
	String(const char* str="")
	{
		//构造string类对象时，如果传递nullptr指针，认为程序非法进行断言
		if (nullptr == str)
		{
			assert(false);
			return;
		}
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}
	String(const String& s)
		:_str(new char[strlen(s._str) + 1])//重新申请空间，避免多个对象共享空间
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s)
	{
		if (this !=&s)
		{
			char* pStr = new char[strlen(s._str) + 1];
			strcpy(pStr, s._str);
			delete[] _str;  //释放原来空间
			_str = pStr;//给新的空间的地址
		}
		return *this;
	}
	~String()
	{
		if (_str)
		{
			delete[] _str;
			_str = nullptr;
		}
	}
private:
	char* _str;
};

写时拷贝
写时拷贝可以理解为一种拖延症，是在浅拷贝的基础之上增加了引用计数的方式来实现的。

引用计数：用来记录资源使用者的个数。 在构造时，将资源的计数给成1，每增加一个对象使用该资源，就给计数增加1，当某个对象被销毁时，先给该计数减1，然后再检查是否需要释放资源，如果计数为1，说明该对象是资源的最后一个使用者，将该资源释放；否则就不能释放，因为还有其他对象在使用该资源。