String-引用计数的写时拷贝

【写时拷贝】

何为写时拷贝呢？？？

提到写时拷贝就不得不提起浅拷贝和深拷贝，深拷贝补充了浅拷贝的不足，而写时拷贝补充了深拷贝的不足，那么到底是怎么补充的呢？下面，给大家细细道来。

其实写时拷贝就是当你读取到这个已经存在的空间时，并不会立刻开辟出一个一模一样的空间出来给你，而是用计数的方式来延迟拷贝，当你真正需要拷贝的时候，才会开辟空间给你。也就是延迟的深拷贝。

下面来看看浅拷贝和深拷贝是怎么实现的：

1.浅拷贝

浅拷贝是指源对象与拷贝对象共用一份实体，仅仅是引用的变量不同（名称不同）。

用草图来解释更直观：



下面看浅拷贝的代码：

#include<iostream>
using namespace std;
class AA
{
...
};

int main(void)
{
AA a1;
AA a2(a1);
return 0;
}

浅拷贝的缺陷：我们看到对象a1和a2地址一样，指向同一块空间，当类中的成员变量包括指针时，而又没有定义自己的拷贝构造函数，那么在拷贝一个对象的情况下，就会调用其默认拷贝构造函数，这个函数只是对其成员变量做了个简单的拷贝，即位拷贝，它们指向的还是同一块存储空间，当调用析构函数时，就会多次析构造成程序崩溃。

2.深拷贝

深拷贝是为了解决浅拷贝中同一快空间多次释放的问题。

深拷贝是自己重新开一块空间，将源空间的数据拷贝到新的空间，从而实现拷贝。



代码如下：

String(const String& str)
{
_str=new char[strlen(str._str)+1];
strcpy(_str,str._str);
}

this->_str拥有了自己的一块空间。

【深拷贝的现代写法】

String(const String& str)
{
_str=NULL;
String tmp(str._str);
swap(_str,tmp._str);
}

3.写实拷贝

从上面的浅拷贝和深拷贝中，我们看到了它们俩的很多问题，那么写实拷贝就很好了解决了这些问题，那么它是如何解决的呢？

写实拷贝有两种方式：

方式一：

在浅拷贝的基础上，在创建一个指针变量的空间，用来计数控制析构来实现拷贝。



代码：

class String1
{
public:
String1(const char* str = ) //构造函数
：_str(new char[strlen(str)+1])
,_refCount(new int(1))
{
strcpy(_str,str);
}
String1(String1&  s)//拷贝构造
:_str(s._str)
,_refCount(s._refCount)
{
(*refCount)++;
}

~String1()
{
if(--(*_refCount)==0)
{
delete[] _str;
delete _refCount;
}

}

private:
char* _str;
int* _refCount;
};

当然，考虑到赋值运算符的重载时要考虑多种情况：



具体代码如下：

String1 & operator=(const String1& s)
{
if(_str!=s._str)
{
if(--(*_refCount)==0)
{
delete[] _str;
delete _refCount;
}
_str=s._str;
_refCount=s._refCount;
*(_refCount)++;
}
return *this;
}

写时拷贝：

void CopyOnWrite()
{
if(*_refCount>1)
{
char * newstr=new char[strlen(_str)];
strcpy(newstr,_str);
(*_refCount)--;
_str=newstr;
_refCount=new int(1);
}
}

方式二：

开辟一个空间，前面4个字节为计数器count，剩下的为字符串_str的空间


代码实现如下：

String(const char* str=)
:_str(new char[strlen(str)+5])
{
strcpy(_str+4,str);
*((int*)_str)=1;
_str+=4;
}

String(const String&s)
:_str(s._str)
{
(*(int*)(_str-4))++;
}

~String()
{
if(--*((int*)(_str-4))==0)
{
delete[] (_str-4);
}
}

String& operator=(const String& s)
{
if(_str!=s._str)
{
if(--GetRefCount()==0)
{
delete[](_str-4);
}
_str=s._str;
GetRefCount()++;
}

return *this;
}

int& GetRefCount()
{
return (*(int*)(_str-4));
}