c++基础自己实现一个String类（COW）

写时拷贝（Copy On Write） 使用了引用计数，在开辟空间时会多开辟4个字节用来保存引用计数的值。当第一个对象构造时，String的构造函数会根据传入的参数从堆上分配内存，当有其他对象需要这块内存时，计数器++，当有对象进行析构释放时，引用计数–，直到最会一个对象被析构，此时计数器为0。只有这样程序才会真正的释放掉这块从堆上分配的内存。

#include <iostream>
#include <Windows.h>
#pragma warning (disable:4996)
using namespace  std;
class String
{
public:
	String(const char* pStr = "") //构造函数
		:_pStr(new char[strlen(pStr) + 4 + 1])//+4多创建的四个字节用来保存当前地址有几个对象
	{
		if (NULL == pStr)
		{
			*((int*)_pStr) = 1;//前4个字节用来计数
			_pStr += 4;//向后偏移4个字节
			*_pStr = '\0';
		}
		else
		{
			*((int *)_pStr) = 1;//前4个字节用来计数
			_pStr += 4;//向后偏移4个字节
			strcpy(_pStr, pStr);//拷贝字符串
		}
	}
	String(const String& s)//拷贝构造函数
		:_pStr(s._pStr)
	{
		++(*(int*)(_pStr - 4));//向前偏移4个字节将计数+1
	}
	~String()//析构函数
	{
		if (NULL == _pStr)
		{
			return;
		}
		else
		{
			if (--(*(int*)(_pStr - 4)) == 0)
			{
				delete[](_pStr - 4);
				_pStr = NULL;
			}
		}
	}
	//重载赋值运算符=
	String& operator=(const String& s)
	{
		if (_pStr != s._pStr)
		{
			if (--(*(int*)(_pStr - 4)) == 0)//释放旧空间
			{
				delete[](_pStr - 4);
				_pStr = NULL;
			}
			_pStr = s._pStr;//指向新空间
			++(*(int*)(_pStr - 4));//计数+1
		}
		return *this;
	}
	//重载下标访问操作符
	char& operator[](size_t t)
	{
		if (t >= 0 && t < strlen(_pStr))//下标非法判断
		{
			if ((*(int*)(_pStr - 4)) > 1)//多个对象指向同一块空间
			{
				char *pTemp = new char[strlen(_pStr) + 4 + 1];//开辟临时空间
				pTemp += 4;//向后偏移4个字节
				strcpy(pTemp, _pStr);//拷贝字符串
				--(*(int*)(_pStr - 4));//计数-1
				_pStr = pTemp;//将当前的对象指向临时空间
				*((int*)(_pStr - 4)) = 1;//将新空间的计数置为1
			}
			return _pStr[t];
		}
	}
	
	friend std::ostream & operator<<(std::ostream & out, String & A)
	{
		cout << A._pStr << endl;
		return out;
	}
private:
	char *_pStr;
};
void FunTest()
{
	String s1("Hello world");
	std::cout << s1;

	String s2(s1);
	std::cout << s2;


	String s3 = s2;
	s3[3] = 'm';
	std::cout << s3;
}
int main()
{
	FunTest();

	system("pause");
	return 0;
}

结果：

来自：https://blog.csdn.net/qq_41035588/article/details/83963917