写时拷贝

浅拷贝
        当类中有指针对象时，拷贝构造和赋值运算符只进行值拷贝，两个指针指向同一块内存空间，当一个指针释放掉时，另一个指针不知道空间已经归还给系统，继续对这块内存操作，导致系统崩溃。

深拷贝
    源对象和拷贝对象相互独立，其中一个对象的改动不会给另一个对象造成影响
    拷贝的时候会为新对象开辟一块新的内存空间，然后将原对象的内容拷贝到新开辟的空间，析构时各自释放各自的。如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。

写时拷贝
    写时拷贝在写的时候（即改变字符串的时候）才会真正的开辟空间拷贝（深拷贝），如果只是对数据的读时，只会对数据进行浅拷贝。
    写时拷贝技术是通过"引用计数"实现的，在分配空间的时候多分配4个字节，用来记录有多少个指针指向块空间，当有新的指针指向这块空间时，引用计数加一，当要释放这块空间时，引用计数减一(假装释放)，直到引用计数减为0时程序才会真正的释放掉这块从堆上分配的内存。当有的指针要改变这块空间的值时，再为这个指针分配自己的空间。

#include <iostream>

class String
{
public:
	String()
	{
		pstr=new char[5];
		pstr+=4;
		GetRef()=1;
	}
	String(char* str)
	{
		int len=strlen(str);
		pstr=new char[len+5];
		pstr+=4;
		strcpy(pstr,str);
		GetRef()=1;
	}
	String(const String& rhs):pstr(rhs.pstr)
	{
		++GetRef();
	}
	String& operator=(const String& rhs)
	{
		if(this!=&rhs)
		{
			if(--GetRef()==0)
			{
				delete [](pstr-4);
			}
			pstr=rhs.pstr;
			GetRef()++;
		}		
		return *this;
	}
	~String()
	{
		if(--GetRef()==0)
		{
			delete[] (pstr-4);
		}
		pstr=NULL;
	}  
	char& operator[](int index)
	{
		if(GetRef()!=1)
		{
			char *p=new char[strlen(pstr)+5];
			p+=4;
			strcpy(p,pstr);
			GetRef()--;
			pstr=p;
			GetRef()=1;
		}
		return pstr[index];
	}
private:
	int& GetRef()
	{
		return *(int *)(this->pstr-4);
	}
	char *pstr;
};

int main()
{
	String str1("hello");
	String str2(str1);
	String str3(str2);
	String str4("world");
	str1 = str4;
	str1[0] = 'h';
	std::cout << str1[0] << std::endl;
	return 0;
}

运行结果：

参考
https://blog.csdn.net/qq_41035588/article/details/83963917#1__484
https://blog.csdn.net/m0_37956168/article/details/74898047