C++ 简易string类实现（五）-进一步抽象

前四篇所叙述的每一件事情，都必须动用到我们感兴趣的那个class的源代码.但如果我们想要将reference counting施行于程序库中一个名为Widget的class呢？程序库的行为不是我们可以更改的，所以没办法让Widget继承自RCObject，也就无法对Widget使用smart RCPtrs.

但只要稍微修改设计，我们就可以为任何类型加上reference counting能力.

首先，让我们考虑，如果令Widget继承自RCObject，我们的设计看起来将如何.这种情况下，我们必须增加一个RCWidget class给clients使用，但每件事情都极类似先前的String/StringValue例子：RCWidget扮演String角色，Widget扮演StringValue的角色.整个设计看起来去如下：

现在我们可以将”计算机科学领域中大部分问题得以解决”的原理施展出来.我们可以加上一层间接性.是的，我们增加一个新的CountHolder class，用以持有引用次数，并令CountHolder继承自RCObject.我们也令CountHolder内含一个指针，指向一个Widget.然后将smart RCPtr template以同样聪明的RCIPtr template取代，后者知道CountHolder class 的存在.RCIPtr的”I”意指”indirect”（间接）.修改后的设计如下：

就像”StringValue只是实现细节，不需要让String的用户知道”一样，CountHolder也是实现细节，不需要让RCWidget的用户知道.事实上，它是RCIPtr的实现细节，所以我们把它嵌套放进RCIPtr class的内部.RCIPtr的声明如下：

template<typename T>
class RCIPtr
{
public:
    RCIPtr(T* realPtr = nullptr);

    RCIPtr(const RCIPtr& rhs_);

    RCIPtr& operator=(const RCIPtr& rhs_);

    ~RCIPtr();

public:
    const T* operator->() const;

    T* operator->();

    const T& operator*() const;

    T& operator*();

private:
    void init();

    void makeCopy();

private:
    struct CountHolder : public RCObject
    {
        T* ptr;

        ~CountHolder()
        {
            if (ptr != nullptr)
            {
                delete ptr;
                ptr = nullptr;
            }
        }
    };

    CountHolder* _counter;
};

RCIPtr和RCPtr之间存在两个差异.第一，”RCPtr对象”之间指向实值，而”RCIPtr对象”通过中介层”CountHolder”对象指向实值；第二，RCIPtr将operator->和operator*重载了，如此一来，只要有non-const access发生于被指物上，copy-on-write（写时进行复制）就会自动执行.

RCIPtr定义如下：

template<typename T>
void RCIPtr<T>::init()
{
    if (_counter->isShareable() == false)
    {
        auto oldptr = _counter->ptr;
        _counter = new CountHolder();
        _counter->ptr = new T(*oldptr);
    }
    _counter->addReference();
}

template<typename T>
RCIPtr<T>::RCIPtr(T* realPtr /* = nullptr */)
    : _counter(new CountHolder())
{
    _counter->ptr = realPtr;
    init();
}

template<typename T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs_)
    : _counter(rhs_._counter)
{
    init();
}

template<typename T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs_)
{
    if (_counter ！ = rhs_._counter)
    {
        _counter->removeReference();
        _counter = rhs_._counter;
        init();
    }
    return *this;
}

template<typename T>
RCIPtr<T>::~RCIPtr()
{
    _counter->removeReference();
}

template<typename T>
const T* RCIPtr<T>::operator->() const
{
    return _counter->ptr;
}

template<typename T>
T* RCIPtr<T>::operator->()
{
    makeCopy();
    return _counter->ptr;
}

template<typename T>
const T& RCIPtr<T>::operator*() const
{
    return *(_counter->ptr);
}

template<typename T>
T& RCIPtr<T>::operator*()
{
    makeCopy();
    return *(_counter->ptr);
}

template<typename T>
void RCIPtr<T>::makeCopy()
{
    if (_counter->isShared())
    {
        auto oldptr = _counter->ptr;
        _counter->removeReference();
        _counter = new CountHolder();
        _counter->ptr = new T(*oldptr);
        _counter->addReference();
    }
}

有了RCIPtr，RCWidget的实现就很容易了，因为RCWidget的每一个函数都只是通过底层的RCIPtr转调对应的Widget函数.示例如下：

class Widget
{
public:
    void doThis()
    {
        std::cout << "doThis" << std::endl;
    }
};

class RCWidget
{
public:
    void doThis()
    {
        _value->doThis();
    }

private:
    RCIPtr<Widget> _value;
};

对于String类，我们只需要将C++ 简易string类实现（一）参考上述Widget和RCWidget的例子，生成一个对应的RCString就OK了；

小结：通过不断的抽象，最终将引用计数类和用户自定义类完全解耦，而且引用计数类还可以重用于其它用户自定义类，简直 完美！！！

完整代码如下：

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 RCIPtr
{
public:
    RCIPtr(T* realPtr = nullptr);

    RCIPtr(const RCIPtr& rhs_);

    RCIPtr& operator=(const RCIPtr& rhs_);

    ~RCIPtr();

public:
    const T* operator->() const;

    T* operator->();

    const T& operator*() const;

    T& operator*();

private:
    void init();

    void makeCopy();

private:
    struct CountHolder : public RCObject
    {
        T* ptr;

        ~CountHolder()
        {
            if (ptr != nullptr)
            {
                delete ptr;
                ptr = nullptr;
            }
        }
    };

    CountHolder* _counter;
};

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>
void RCIPtr<T>::init()
{
    if (_counter->isShareable() == false)
    {
        auto oldptr = _counter->ptr;
        _counter = new CountHolder();
        _counter->ptr = new T(*oldptr);
    }
    _counter->addReference();
}

template<typename T>
RCIPtr<T>::RCIPtr(T* realPtr /* = nullptr */)
    : _counter(new CountHolder())
{
    _counter->ptr = realPtr;
    init();
}

template<typename T>
RCIPtr<T>::RCIPtr(const RCIPtr& rhs_)
    : _counter(rhs_._counter)
{
    init();
}

template<typename T>
RCIPtr<T>& RCIPtr<T>::operator=(const RCIPtr& rhs_)
{
    if (_counter ！ = rhs_._counter)
    {
        _counter->removeReference();
        _counter = rhs_._counter;
        init();
    }
    return *this;
}

template<typename T>
RCIPtr<T>::~RCIPtr()
{
    _counter->removeReference();
}

template<typename T>
const T* RCIPtr<T>::operator->() const
{
    return _counter->ptr;
}

template<typename T>
T* RCIPtr<T>::operator->()
{
    makeCopy();
    return _counter->ptr;
}

template<typename T>
const T& RCIPtr<T>::operator*() const
{
    return *(_counter->ptr);
}

template<typename T>
T& RCIPtr<T>::operator*()
{
    makeCopy();
    return *(_counter->ptr);
}

template<typename T>
void RCIPtr<T>::makeCopy()
{
    if (_counter->isShared())
    {
        auto oldptr = _counter->ptr;
        _counter->removeReference();
        _counter = new CountHolder();
        _counter->ptr = new T(*oldptr);
        _counter->addReference();
    }
}