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