C++ String 写时拷贝

当类里面有指针对象时，采用简单的赋值浅拷贝，使得两个指针指向同一块内存，则析构两次，存在内存奔溃的问题，因此浅拷贝中利用引用计数。

//引用计数浅拷贝

class String
{
public:
 String(char*str = "")
  :_str(new char[strlen(str) + 1])
  , _pRefCount(new int(1))
 {}
 String(const String & s)
  :_str(s._str)
  , _pRefCount(s._pRefCount)
 {
  ++(*_pRefCount);
 }
 String &operator=(const String & s)
 {
  if (this != &s)
  {
   if (--(*_pRefCount) == 0)
   {
    delete[]_str;
    delete _pRefCount;
   }
   _str = s._str;
   _pRefCount = s._pRefCount;
   ++(*_pRefCount);
  }
  return *this;
 }
 ~String()
 {
  if (--(*_pRefCount)==0)
  {
   delete[]_str;
  }
 }
private:
 char*_str;
 int*_pRefCount;
};

同之前的delete[ ] 一样，当我们为string 分配内存时，总是多分配一个空间来存储引用计数。在每个内存块的前四个字节来存放一个整数，而真正的内容则在其后。

//写时拷贝

class String
{
public:
 String(const char*str="")
  :_str(new char[strlen(str)+5])
 {
  cout << "String()" << endl;
  _str += 4;
  _GetRefCount(_str) = 1;
  strcpy(_str, str);
 }
 
 String(const String &s)
  :_str(s._str)
 {
  cout << "String(const String &s)" << endl;
  ++_GetRefCount(_str);
 }
 
 String&operator=(const String &s)
 {
  if (_str!=s._str)
  {
   _Release();
   _str = s._str;
   ++_GetRefCount(_str);
  }
  return *this;
 }
 
 ~String()
 {
  cout << "~String()" << endl;
  _Release();
 }
 
//写时才拷贝，当两个对象共享一块内存时，若其中的一个需要修改内容，则此时谁修改，谁在另外地方申请新的空间，将之前共用内存块的引用计数减一，将内容复制到新的空间，并把引用计数设置为1.
 char&operator[](size_t Index)
 {
  if (_GetRefCount(_str) > 1)
  {
   --(_GetRefCount(_str));
   char*tmp = new char[strlen(_str) + 5];
   tmp += 4;
   _GetRefCount(tmp) = 1;
   strcpy(tmp, _str);
   _str = tmp;
  }
  return _str[Index];
 }

 char* C_Str()
 {
  return _str;
 }
private:

 int& _GetRefCount(char *str)
 {
  return *(int*)(str - 4);
 }
 
 void _Release()
 {
  if (--_GetRefCount(_str) == 0)
  {
   delete[](_str - 4);
  }
 }
 
private:
 char*_str;
};
 
void Test2()
{
 String s1("xello");
 String s2(s1);
 s1[0] = 'h';
 cout << s1.C_Str() << endl;
 cout << s2.C_Str() << endl;
}
 
int main()
{
 Test2();
 system("pause");
 return 0;
}