C++ 简易string类实现（六）-真正的写时复制

在C++ 简易string类实现（二）-引用计数中，我们引入了写时复制（copy on write），但因为C++编译期无法告诉我们operator[]是被用于读取或写，出于安全，这里假设对non-const 的operator[]的调用都是写操作，这样虽然能够正常运行，但是诸如下面的代码：

String str1 = "123";std::cout << str1[2];   //读操作str1[1] = 2;            //写操作

第2行里，明显是一个读操作，但是为了安全，也会被假设在写操作.这样使用上固然没问题，但是依然不是真正的写时复制（copy on write），那么有没有办法使得编译期针对operator[]，可以”智能”地知道，何时是写操作，何时是读操作吗？

下面是C++ 简易string类实现（二）-引用计数中String类的non-const版的operator[]：

char& String::operator[](size_t index_)

返回类型是char&，这里的问题是，对于写操作或者读操作，char&没有有效的办法做区分.在 C++ 简易string类实现（五）-进一步抽象中，我们引入CountHolder的一个思想是，”加上一层间接性”.这里我们同样加入一层间接性，将返回的char类型包装是一个类，我们知道，对于一个类（而不是其成员函数的返回类型），可以很容易知道其调用是写操作还是读操作（利用所调用的成员函数区分）.基于此，我们引入proxy class（代理类），令String的operator返回是字符串中字符的proxy，而不返回字符本身.然后我们可以等待，看看这个proxy如何被调用.如果它被读，我们可以（有点过时地）将operator[]的调用动作视为一个读取动作.如果它被写，我们必须将operator[]的调用视为一个写操作.

对于即将使用的proxy，有3件事需呀做：
（1）产生它，本例也就是指定它代表哪一个字符串中的哪一个字符；
（2）以它作为赋值动作（assignment）的目标（接受端），这种情况下，是对它所代表的字符串内的字符做赋值动作.如果这么使用，proxy代表的将是”调用operator[]函数”的那个字符串的左值运用.
（3）以其它方式使用之.如果这么使用，proxy表现的是”调用operator[]函数”的那个字符串的右值运用.

下面是一个带有引用计数特性的String class，其中利用proxy class 来区分operator[]的左值运用（写操作）和右值运用（读操作）：

class String{    friend class CharProxy;    //访问String私有变量public:    String(const char* str_ = "");    class CharProxy    {    public:        CharProxy(String& str_, int index_);        //构造        CharProxy& operator=(const CharProxy& rhs_);    //左值运用        CharProxy& operator=(char ch_);     //左值运用        operator char() const;      //右值运用    private:        //记录所引用的String对象和当前字符的下标，        //在左值运用时，可以修改String对象的值        String& _theString;        int _charIndex;    };    const CharProxy operator[](int index) const;    CharProxy operator[](int index);private:    struct StringValue : public RCObject    {        char* ptr;        StringValue(const char* str_);        StringValue(const StringValue& rhs_);        ~StringValue();    private:        void init(const char* str_);    };    RCPtr<StringValue> _value;};

这里的String class和C++ 简易string类实现（四）-自动操作引用次数中的那个String class之间唯一的差别就是，此处的两个operator[]都返回CharProxy对象.然而对于用户可以忽略这点（对于某些操作，例如对CharProxy变量做&操作会有问题，下面会说到），犹如operator[]返回字符一样：

String str1 = "123";std::cout << str1[2];   //合法,有效运转str1[1] = 2;            //合法,有效运转

考虑这行代码

std::cout << str1[2];

表达式str1[2]产生一个CharProxy对象.此对象不曾定义output操作符，所以编译器赶紧寻找一个它能够实施的隐式类型转换，使得operator<<调用操作能够成功.编译器真的找到了一个：将CharProxy隐式转型为char.此转换函数声明于CharProxy函数内.于是编译器自动调用这个转换操作符，于是CharProxy所表现的字符串字符被打印出去.这是典型的CharProxy-to-char转换，发生在所有”被用来作为右值”的CharProxy对象身上.

左值运用的处理方式又不相同，例如这行代码

str1[1] = 2; 

和上例一样，表达式str1[1]导出一个CharProxy对象，但这次这个对象是assignment动作的目标物.会调用哪个assignment操作符呢？由于目标物是个CharProxy，所以被调用的assignment操作符会是CharProxy class所定义的那个.这很重要，因为在CharProxy的assignment操作符内，我们确知”被赋值的CharProxy对象被用来作为一个左值”.我们因此知道proxy所代表的那个”字符串内的字符”将被用来作为一个左值，并因此采取所有必要行动，对该字符实施左值处理.

即使是以下这段代码：

String s1 = "1234";String s2 = "12333";s1[3] = s2[3]; 

最后一行调用的两个CharProxy对象的assignment操作符，在该操作符中我们知道左端对象被用来作为一个左值，右端对象被用来作为一个右值.

对于String的operator[]

const CharProxy operator[](int index) const;CharProxy operator[](int index);

每个函数都只是产生并返回”被请求字符”的一个proxy.没有任何动作施加于此字符身上：我们延缓此等行为，直到知道该行为是”读取”还是”写”.

虽然Proxy class很适合用来区分operator[]的左值运用和右值运用，但是这项技术并非没有缺点.我们希望proxy object能够无间隙地取代它们所代表的对象，但是这样的想法却很难达成.因为除了赋值（assignment）之外，对象亦有可能在其它情境下被当做左值使用，而在那种情况下的proxies常常会有与真实对象不同的行为.

例如下述代码：

String s1 = "123456";char* p = &s2[1];   //错误,无法通过编译

第二行代码无法通过编译的原因是，&s2[1]返回的是一个CharProxy*类型指针，由于不存在任何函数可以将CharProxy * 转换为 char *，所以上述的p的初始化动作无法通过编译.一般而言，”对proxy取址”所获得的指针类型和”对真实对象地址”所获得的指针类型不同.

为了消除这个难点，我们需要在CharProxy class内将取址（address of）操作符加以重载：

class String{public:    ...    class CharProxy    {    public:        ...        char* operator&();        const char* operator&() const;        ...    };    ...};

对应的实现为：

char* String::CharProxy::operator&(){    //确定"标记的字符"（本函数返回一个指针指向它）所属的字符串实值不为    //任何其它String对象共享（如果共享，就做一份专属副本出来）    if (_theString._value->isShared())    {        _theString._value = new StringValue(_theString._value->ptr);    }    //我们不知道clients会将本函数返回的指针保留多久，所以"目标字符"    //所属的字符串实值（一个StringValue对象）绝不可以被共享    _theString._value->markUnshareable();    return &(_theString._value->ptr[_charIndex]);}const char* String::CharProxy::operator&() const{    return &(_theString._value->ptr[_charIndex]);}

此时，

String s1 = "123456";char* p = &s2[1];   //编译通过

问题得以解决，但本质上，CharProxy和char是不同的，我们可以通过重载的方式解决遇到的问题，这样无疑增加了工作量，但现在我们在copy-on-copy上的工作已经做到很好了，这些工作量的增加还是可以接受的，当然可以通过将一些通用的运算符加以封装，得以复用，然后针对具体的类，再增加额外所需的函数.

完整代码如下，
结构图：

class RCObject{public:    RCObject();    RCObject(const RCObject& rhs_);    //使RCObject成为抽象基类，但该纯虚函数需要提供    //定义，不然会使被继承的类无法在栈上创建（原因可    //查阅如何仅在堆上或栈上分配内存）    virtual ~RCObject() = 0;       public:    void addReference();    void removeReference();    void  markUnshareable();    bool isShareable() const;    bool isShared() const;private:    RCObject& operator=(const RCObject&) = delete;private:    int refCount;    bool shareable;};template<typename T>class RCPtr{public:    RCPtr(T* realPtr = 0);    RCPtr(const RCPtr& rhs_);    RCPtr& operator=(const RCPtr& rhs_);    ~RCPtr();public:    T* operator->() const;    T& operator*() const;private:    void init();private:    T* _ptr;};class String{    friend class CharProxy;public:    String(const char* str_ = "");    class CharProxy    {    public:        CharProxy(String& str_, int index_);        //构造        CharProxy& operator=(const CharProxy& rhs_);    //左值运用        CharProxy& operator=(char ch_);     //左值运用        operator char() const;      //右值运用        char* operator&();        const char* operator&() const;    private:        //记录所引用的String对象和当前字符的下标，        //在左值运用时，可以修改String对象的值        String& _theString;        int _charIndex;    };    const CharProxy operator[](int index) const;    CharProxy operator[](int index);private:    struct StringValue : public RCObject    {        char* ptr;        StringValue(const char* str_);        StringValue(const StringValue& rhs_);        ~StringValue();    private:        void init(const char* str_);    };    RCPtr<StringValue> _value;};

RCObject::RCObject()    :refCount(0), shareable(true)   //refCount初始化为0，其值完全有RCPtr控制{}RCObject::RCObject(const RCObject&)//调用无参构造函数，注意：该调用仅能在//初始化成员列表里，如果在函数实现内调用，//那么仅仅是在栈上生成新的对象，而不是完成//该对象的成员初始化    :RCObject(){    std::cout << "RCObject" << std::endl;}RCObject::~RCObject(){    //std::cout << "~RCObject" << std::endl;}void RCObject::addReference(){    ++refCount;}void RCObject::removeReference(){    if (--refCount == 0)    {        delete this;    }}void RCObject::markUnshareable(){    shareable = false;}bool RCObject::isShareable() const{    return shareable;}bool RCObject::isShared() const{    return refCount > 1;}template<typename T>RCPtr<T>::RCPtr(const RCPtr& rhs_)    : _ptr(rhs_._ptr){    init();}template<typename T>void RCPtr<T>::init(){    if (_ptr == nullptr)    {        return;    }    if (_ptr->isShareable() == false)    {        //如果其值不可共享，那么就赋值一份        //注意，这里将新对象的赋值行为，由之前的        //String转移到RCPtr，此时T（在原有的String实现中是StringValue）        //若要完成深拷贝，T（StringValue）必须重写赋值运算符        _ptr = new T(*_ptr);    }    //计数器完全由RCPtr控制，即使上个if语句内重新赋值的对象    //其引用计数也由RCPtr控制，故将RCObject的refCount初值赋值0    _ptr->addReference();   }template<typename T>RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs_){    if (_ptr != rhs_._ptr)    {        if (_ptr != nullptr)        {            _ptr->removeReference();        }        _ptr = rhs_._ptr;        init();    }    return *this;}template<typename T>RCPtr<T>::~RCPtr(){    if (_ptr != nullptr)    {        _ptr->removeReference();    }}template<typename T>T* RCPtr<T>::operator->() const{    return _ptr;}template<typename T>T& RCPtr<T>::operator*() const{    return *_ptr;}const String::CharProxy String::operator[](int index_) const{    //为了简洁，这里略去对下标的安全检查    return CharProxy(const_cast<String&>(*this), index_);}String::CharProxy String::operator[](int index_){    //将决定读写的权利交给CharProxy，这里当做读，简单的返回    //CharProxy实例    return CharProxy(*this, index_);}String::CharProxy::CharProxy(String& str_, int index_)    : _theString(str_), _charIndex(index_){}String::CharProxy& String::CharProxy::operator=(const CharProxy& rhs_){    if (_theString._value->isShared())    {        _theString._value = new String::StringValue(_theString._value->ptr);    }    //不再需RCObject中的shareable变量及对应的成员函数    _theString._value->ptr[_charIndex] =        rhs_._theString._value->ptr[rhs_._charIndex];    return *this;}String::CharProxy& String::CharProxy::operator=(char ch_){    if (_theString._value->isShared())    {        _theString._value = new StringValue(_theString._value->ptr);    }    _theString._value->ptr[_charIndex] = ch_;    return *this;}String::CharProxy::operator char() const{    return _theString._value->ptr[_charIndex];}char* String::CharProxy::operator&(){    //确定"标记的字符"（本函数返回一个指针指向它）所属的字符串实值不为    //任何其它String对象共享（如果共享，就做一份专属副本出来）    if (_theString._value->isShared())    {        _theString._value = new StringValue(_theString._value->ptr);    }    //我们不知道clients会将本函数返回的指针保留多久，所以"目标字符"    //所属的字符串实值（一个StringValue对象）绝不可以被共享    _theString._value->markUnshareable();    return &(_theString._value->ptr[_charIndex]);}const char* String::CharProxy::operator&() const{    return &(_theString._value->ptr[_charIndex]);}void String::StringValue::init(const char* str_){    ptr = new char[strlen(str_) + 1];    strcpy(ptr, str_);}String::StringValue::StringValue(const StringValue& rhs_){    init(rhs_.ptr);}String::StringValue::StringValue(const char* str_){    init(str_);}String::StringValue::~StringValue(){    if (ptr != nullptr)    {        delete[] ptr;    }}