带引用计数的String类简单实现

很好的一个示范例子，设计到类设计，模版，继承，封装。

麻雀虽小五脏俱全，废话少说，来看代码：

主程序：

#include <iostream>

#include "rcstring.h"

int main(void)
{
    String s("hello");

    std::cout << s[2] << std::endl;

    std::cout << "Hello World!" << std::endl;

    return 0;
}

String声明和实现：

//rcstring.h
#include "rcobject.h"
#include "rcptr.h"

class String {
public:
    String(const char *value = "");
    const char& operator[] (int index) const;
    char & operator[] (int index);
private:
    struct StringValue: public RCObject {
        StringValue(const char *initValue);
        StringValue(const StringValue &rhs);
        ~StringValue();

        void init(const char *initValue);

        char *data;
    };

    RCPtr<StringValue> value;
};

//rcstring.cpp
#include "rcstring.h"
#include <cstring>

String::String(const char *initValue)
    :value(new StringValue(initValue))
{

}

const char& String::operator[] (int index) const
{
    return value->data[index];
}

char& String::operator[] (int index)
{
    if(value->isShared())
        value = new StringValue(value->data);

    value->markUnshareable();

    return value->data[index];
}

String::StringValue::StringValue(const char *initValue)
{
    init(initValue);
}

String::StringValue::StringValue(const StringValue& rhs)
{
    init(rhs.data);
}

String::StringValue::~StringValue()
{
    delete [] data;
}

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

引用计数类rcobject：

//rcobject.h

class RCObject {
protected:
    RCObject();
    RCObject(const RCObject &rhs);
    RCObject& operator=(const RCObject &rhs);
    virtual ~RCObject() = 0;

public:
    void addReference();
    void removeReference();
    void markUnshareable();
    bool isShareable() const;
    bool isShared() const;
private:
    int refCount;
    bool shareable;
};


//rcobject.cpp
#include "rcobject.h"

RCObject::RCObject()
    : refCount(0), shareable(true)
{

}

RCObject::RCObject(const RCObject &rhs)
    :refCount(0), shareable(true)
{

}

RCObject& RCObject::operator=(const RCObject &rhs)
{
    return *this;
}

RCObject::~RCObject()
{

}

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

用来管理rcstring属性的简单智能指针：

//rcptr.h

template <typename T>
class RCPtr {
public:
    RCPtr(T *realPtr = 0);
    RCPtr(const RCPtr &rhs);
    ~RCPtr();

public:
    RCPtr& operator= (const RCPtr &rhs);
    T* operator-> ()const;
    T& operator* ()const;

private:
    T *pointee;
    void init();
};

template <typename T>
RCPtr<T>::RCPtr(T *realPtr)
    :pointee(realPtr)
{
    init();
}

template <typename T>
RCPtr<T>::RCPtr(const RCPtr& rhs)
    :pointee(rhs.pointee)
{
    init();
}

template <typename T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs)
{
    if(pointee != rhs.pointee) {
        if(pointee) pointee->removeReference();

        pointee = rhs.pointee;

        init();
    }

    return *this;
}

template <typename T>
RCPtr<T>::~RCPtr()
{
    if(pointee) pointee->removeReference();
}

template <typename T>
T* RCPtr<T>::operator-> () const 
{
    return pointee;
}

template <typename T>
T& RCPtr<T>::operator* () const
{
    return *pointee;
}

template <typename T>
void RCPtr<T>::init()
{
    if(pointee == 0) return;
    if(pointee->isShareable() == false)
        pointee = new T(*pointee);

    pointee->addReference();
}