C++ 简易string类实现（四）-自动操作引用次数

在 C++ 简易string类实现（三）-抽离引用计数中，RCObject class给了我们一个放置引用次数的空间，也给了我们一些member functions，用来操作引用次数.然而，这些函数的调用动作还是一定得由我们手动式地安插到其它class内.并且还是有劳String copy constructor和String assignment operator调用StringValue对象所提供的addReference和removeReference.这太笨拙了，我们希望能够把那些调用操作移至一个可复用的class内，这么一来就可以让诸如String之类的classes的作者不必操心reference counting的任何细节.

每个String对象都内含一个指针，指向StringValue对象，后者用以表现String的值.

class String{private:    struct StringValue : public RCObject{...};    StringValue* _value;    ... };

我们必须能够在任何时候，当任何有趣的事情发生于一个”指向StringValue对象的指针”身上时，操控该StringValue对象内的refCount成员.所谓有趣的事情包括对指针的赋值、重新赋值、销毁.如果我们能够让指针本身侦测这些事情，并自动执行对refCount成员的操控动作，我们就可以自由自在无所挂碍了.不幸的是，指针是十分难搞的家伙，欲通过他们侦测任何事物，并自动对其侦测到的事物作反应，几率十分渺茫.幸运的是，有个办法可以让指针聪明起来：以行为和形貌皆类似指针（但功能更多）的对象取代之.

此对象称为smart pointers.smart pointers支持”成员选取操作符（->）“和”解引用操作符（ ）“，就像真正的指针（dumb pointers）一样；他们也像dumb pointers一样具有强烈的类型性（strongly typed）*，换句话说，不能够令一个smart pointer-to-T指向一个类型T以外的对象.

智能指针（smart pointers）类声明如下：

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;};

RCPtr是一个模板类（template class），用于smart pointers-to-T，T必须支持RCObject接口，因此T通常继承于RCObject.（boost库有个函数（泛型编程）可以在编译期判断A是否是B的派生类）

该templates让smart pointer objects控制其构造、赋值、析构期间发生的事情.当此类事件发生时，这些对象可以自动执行适当的处置行为–以此处目的而言，就是处理它们所指对象的refCount.通过这种方式，String类可以完全剥离对refCount操作相关的代码了，因为这些工作全部交给了RCPtr.

RCPtr类定义如下：

template<typename T>RCPtr<T>::RCPtr(T* realPtr /* = 0 */)    : _ptr(realPtr){    init();}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;}

StringValue函数增加了一个拷贝构造函数，因为对RCObject的管理完全由RCPtr接替，在void RCPtr< T >::init()中，

_ptr = new T(*_ptr);

会调用SringValue的拷贝构造函数，如果StringValue没有提供该函数，就会导致浅拷贝，由此带来的问题是显而易见的.
该拷贝构造函数定义为：

String::StringValue::StringValue(const StringValue& rhs_){    init(rhs_.ptr);}

StringValue类的拷贝构造函数和默认构造函数实现类似，故将通用的代码整合形成一个init函数，init函数定义如下：

void String::StringValue::init(const char* str_){    ptr = new char[strlen(str_) + 1];    strcpy(ptr, str_);}

再来看看此时的String类，

class String{public:    String(const char* str_ = "");public:    const char& operator[](size_t index_) const;    char& operator[](size_t index_);private:    struct StringValue  : public RCObject    {        ...   };   RCPtr<StringValue> _value;};

可以发现，String函数此时相当简单，连拷贝构造函数和赋值运算符都不见了，为什么不需要这两个函数？因为对StringValue类的管理完全由RCPtr负责，此时编译期默认为String实现的拷贝构造函数和赋值运算符已经足够了.

整个String类的结构如下图：

完整代码如下：

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{public:    String(const char* str_ = "");public:    const char& operator[](size_t index_) const;    char& operator[](size_t index_);private:    struct StringValue  : public RCObject    {        char* ptr;        StringValue(const char* str_);        //提供拷贝构造函数，否则还是浅拷贝        StringValue(const StringValue& _rhs);        //不可赋值操作        StringValue& operator=(const StringValue&) = delete;        ~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;}String::String(const char* str_ /* = "" */)    : _value(new StringValue(str_)){}const char& String::operator[](size_t index_) const{    //为了简化代码，不引入_size变量记录字符串长度    if (index_ >= strlen(_value->ptr))    {        throw std::out_of_range("String out of range!");    }    return _value->ptr[index_];}char& String::operator[](size_t index_){    if (index_ >= strlen(_value->ptr))    {        throw std::out_of_range("String out of range!");    }    //本对象和其他String对象共享同一个实值    if (_value->isShared())    {        _value = new StringValue(_value->ptr);    }    _value->markUnshareable();    return _value->ptr[index_];}String::StringValue::StringValue(const char* str_){    init(str_);}String::StringValue::StringValue(const StringValue& rhs_){    init(rhs_.ptr);}String::StringValue::~StringValue(){    if (ptr)    {        delete[] ptr;        ptr = nullptr;    }}void String::StringValue::init(const char* str_){    ptr = new char[strlen(str_) + 1];    strcpy(ptr, str_);}