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