写时拷贝

浅拷贝：

当在进行对象的复制时，只是进行对象数据成员的拷贝，其中默认的拷贝构造函数也是浅拷贝

弊端：

当多个对象共用同一个内存块时，若其中一个对象修改，其他对象的内容也修改，系统会崩溃

深拷贝：

拷贝的是对象本身，会再申请一个内存来存储，修改一个的值不会影响另一个

弊端：

若只使用，不修改，则会导致内存的利用率低

写时拷贝：

引用计数的拷贝时用来解决浅拷贝存在的问题

实现：

我们为每个内存的字符数组添加一个引用计数getRefcount(),即就是在构造函数申请空间的时候多申请出来4个字节。表示有多少个对象使用这块内存，有多少个对象使用这块内存，有多少个对象使用，就让getRefcount()值加1，当对象被析构的时候，让getRefcount()值减1，当getRefcount()值为0的时候，将这块内存释放掉。当然getRefcount()也要实现内存共享，所以它也是一个堆中的数据，每个对象都有一个指向它的指针。
修改前：先拷贝
修改后：深拷贝

参考代码如下：

class String
{
public:

//构造

String(char *p = "") :_str(new char[strlen(p) + 5]())//构造
	{
		_str += 4;//4个字节的引用计数
		strcpy(_str, p);
		getRefcount() = 1;//给地址块赋值1
	}

//拷贝构造

String(const String& rhs) :_str(rhs._str)
{
	++getRefcount();
}

//类内=的重载

String& operator=(const String& rhs)
{
	if (this != &rhs)
	{
		Release();//释放this指针,指向_str的资源
		_str = rhs._str;
		++getRefcount();
	}
	return *this;
}

//类内[]的重载 深拷贝

char& operator[](int index)
{
    //至少两个对象指向内存块，才有开辟内存的必要
	if (getRefcount() != 1)
	{
		char* pnewstr = new char[strlen(_str) + 5]();
		pnewstr += 4; //指向字符串起始位置
		strcpy(pnewstr, _str);
		--getRefcount();
		_str = pnewstr;
		getRefcount() = 1;
	}
	return _str[index];
}

//析构

~String()
{
	Release();
}

//释放内存

private:

void Release()
	{
		if (--getRefcount() == 0)
		{
			delete (_str - 4);//释放内存
		}
		_str = NULL;
	}

//得到数字

int& getRefcount()
{
	return *(int *)(_str - 4); //得到数字
}
char* _str;

};

测试代码：

int main()
{
	String str1("hello");
	String str2(str1);
	String str3("world");
	str3 = str1;
	str1[0] = 'a';
	return 0;
}