String类引用计数的写时拷贝

写时拷贝：

当一个对象被拷贝构造多次，在不改变内容的情况下，多个对象共用同一个空间。

如果某个对象要改变内容，就要另外开辟一块相同的空间，然后改变这个对象的_str指针，再进行写操作

#include<iostream>
#include<assert.h>
using namespace std;

//String类的浅拷贝增删查改（引用计数的写时拷贝）
class String
{
public:
	String(const char* str = "")
		:_str(new char[strlen(str)+1])
		,_ref(new int(1))
		,_size(strlen(str))
		,_capacity(strlen(str))
	{
		strcpy(_str, str);
	}

	String(const String& s)
		:_str(s._str)
		,_ref(s._ref)
		,_capacity(s._capacity)
		,_size(s._size)
	{
		(*_ref)++;
	}

	~String()
	{
		Release();
	}

	void Release()
	{
		if(--(*_ref) == 0)
		{
			delete[] _str;
			delete _ref;
		}
	}

	const char* c_str()
	{
		return _str;
	}

	void CopyOnWrite()	//引用计数的写时拷贝
	{
		if(*_ref > 1)
		{
			char* tmp = new char[_capacity+1];
			if (tmp)
			{
				strcpy(tmp, _str);
				_str = tmp;
				(*_ref)--;
				_ref = new int(1);
			}

			
		}
	}

	void Expand(size_t n)
	{
		if (n>_capacity)
		{
			_str = (char*)realloc(_str, n+1);
			assert(_str);
			_capacity = n;
		}
	}

	void PushBack(char ch)
	{
		CopyOnWrite();
		if (_size == _capacity)
		{
			//因为已经写时拷贝了，扩容的是自己的空间不是原空间
			Expand(_capacity * 2);
		}
		_str[_size++] = ch;
		_str[_size] = '\0';
	}

	char& operator[](size_t pos)
	{
		assert(pos<_size);
		CopyOnWrite();
		return _str[pos];
	}

private:
	char* _str;
	int* _ref;
	size_t _capacity;
	size_t _size;
};