String 类 Copy-On-Write 技术以及使用时存在的风险

先来看一下string 面试时的简易写法（使用的是深拷贝）：

class String
{
String()
:str(new char[1])
{
str[0] = '\0';
}

String(char* p, size_t size)
:str(new char[size + 1])
{
strcpy(str, p);
}

String(String& Str)
:str(new char[strlen(Str.str)+1])
{
strcpy(str, Str.str);
}

String& operator=(String& Str)
{
if (this != &Str)
{
String StrTmp = Str;
swap(str, StrTmp.str);
}
return *this;
}

~String()
{
delete[] str;
}

//深拷贝与浅拷贝

　　当对string的对象不进行修改，也就是只读的时候，我们创建新对象时可以用新的string类中的char*来指向原先旧的string中字符串的起始位置，如果用深拷贝就存在内存浪费的问题，因为我们每构造出一个对象时都是重新开辟新的空间来存储字符串。所以呢 Copy_On_Write的思想被提出来了，Copy_On_Write 就是指在修改string时才开辟空间来保存修改后的string，而如果不修改呢，我们就用浅拷贝，直接用string中char*进行赋值，引用计数加一，析构时如果引用计数减为0，则释放保存字符串的空间。

写实拷贝的模型一：

class String
{
String()
:_str(new char[1]), _count(new int(1))
{
_str[0] = '\0';
}

String(char* p, size_t size)
:_str(new char[size + 1]), _count(new int(1))
{
strcpy(_str, p);
}

String(String& Str)
:_str(Str._str), _count(Str._count)
{
strcpy(_str, Str._str);
*_count++;
}

String& operator=(String& Str)
{
if (this != &Str)
{
if (--*_count == 0)
delete[] _str;
_str = Str._str;
_count = Str._count;
*_count++;
}
return *this;
}

~String()
{
delete[] _str;
}

protected:
char* _str;
int* _count;   //引用计数
};

写实拷贝的模型二：

class String
{
public:
String()
:_str(new char[5])
{
_str = _str + 4;
_str[0] = '\0';
int count = _Count(_str);
count = 1;
}

String(char* p)
:_str(new char[strlen(p) + 5])
{
_str = _str + 4;
strcpy(_str, p);
int& count = _Count(_str);
count = 1;
}

String(String& Str)
:_str(Str._str)
{
++_Count(_str);
}

String& operator=(String& Str)
{
if (this != &Str)
{
if (_Count(_str))
delete[](_str - 4);
_str = Str._str;
++_Count(_str);
}
return *this;
}

~String()
{
if (--_Count(_str) == 0)
delete[] _str;
}

int& _Count(char* p)
{
return *(int*)(p - 4);
}
protected:
char* _str;
};

写实拷贝引发的问题：参见博文

C++ 之 stl::string 写时拷贝导致的问题