基于灵巧指针和引用计数的String类

/**
*利用灵巧指针和引用计数功能实现string类
**/

//类头文件

//smart pointer用来管理类的指针成员，避免内存泄露
template <class T>
class RCPtr
{
public:
RCPtr(T* realPtr = 0);
RCPtr(const RCPtr&);
~RCPtr();
RCPtr& operator=(const RCPtr&);
T* operator->() const;
T& operator*() const;
private:
T* pointee;
void Init();
};

//用于进行引用计数功能的虚基类
class RCObject()
{
public:
void AddReference();
void RemoveReference();
void MarkUnshareable();
bool IsShareable() const;
bool IsShared() const;
protected:
RCObject();
RCObject(const RCObject&);
RCObject& operator=(const RCObject&);
virtual ~RCObject() = 0;
private:
int refCount;
bool shareable;
};

//对string进行引用计数和灵巧指针的应用
class String
{
public:
//没有拷贝构造和赋值以及析构，编译器自动生成
//并且由于灵巧指针的存在，调用StringValue的拷贝，完成自己的功能
String(const char* value = "");
const char& operator[](int index) const;
char& operator[](int index);
private:
//StringValue继承RCObject，从而实现了引用计数功能，在父类进行计数控制
struct StringValue:public RCObject
{
char* data;
StringValue(const char* initValue);
StringValue(const StringValue&);
void Init(const char* initValue);
~StringValue();
};
private:
//灵巧指针
RCPtr<StringValue> value;
};

//实现文件RCObject
RCObject::RCObject():refCount(0),shareable(true){}

//虚基类引用计数为0，是为了让用户控制AddReference
RCObject::RCObject(const RCObject&):refCount(0),shareable(true){}

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

RCObject::~RCObject(){}

void RCObject::addReference()
{
++refCount;
}

void RCObject::removeReference()
{
if(--refCount==0)
delete this;
}

bool RCObject::isShareable() const
{
return shareable;
}

bool RCObject::isShared() const
{
//引用最少为2才被引用了，否则只有自身
return refCount>1;
}

//实现文件RCPtr
template<class T>
void RCPtr<T>::Init()
{
if(pointee==0)
return;
if(!pointee->isShareable())
{
pointee = new T(*pointee);
}
pointee->addReference();
}

template<class T>
RCPtr<T>::RCPtr(T* realPtr):pointee(realPtr)
{
Init();
}

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

template<class T>
RCPtr<T>::~RCPtr()
{
if(pointee)
pointee->RemoveReference();
}

template<class T>
RCPtr<T>& RCPtr<T>::operator=(const RCPtr& rhs)
{
if(pointee != rhs.pointee)
{
if(pointee)
pointee->RemoveReference();
pointee = rhs.pointee;
Init();
}
return *this;
}

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

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

//String::StringValue的实现
void StringValue::Init(const char* initValue)
{
data = new char[strlen(initValue)+1];
strcpy(data,initValue);
}

StringValue::StringValue(const char* initValue)
{
Init(initValue);
}

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

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

//String的实现
String::String(const char* initValue)value(new StringValue(initValue))
{

}

const char& String::operator[](int index) const
{
return value->data[index];
}
//由于不能确定非const的[]是读还是写，所以都按照写来操作
//从新分配内存，并设定为不可共享状态
char& String::operator[](int index)
{
if(value->IsShared())
{
value = new StringValue(value->data);
}
value->MarkUnshareable();
return value->data[index];
}