【C++ techniques】Smart Pointers智能指针

Smart Pointers智能指针

看起来、用起来、感觉起来像内置指针，但提供更多的机能。拥有以下各种指针行为的控制权：

构造和析构；
复制和赋值；
解引。

Smart Pointers的构造、赋值、析构

C++的标准程序库提供的auto_ptr template:
auto_ptr对象是个smart pointer，用来指向诞生于堆内的对象，直到该auto_ptr被销毁为止；当销毁发生时，auto_ptr的析构函数会删除其所指物。

template<class T>
class auto_ptr
{
public:auto_ptr(T* ptr):pointee(ptr){}~auto_ptr(){delete pointee;}...
private:T* pointee;
};

在“同一对象只可被一个auto_ptr拥有”的前提下，上述做法可以有效运作；但当auto_ptr被复制或被赋值，其“对象拥有权”会转移：

template<class T>
class auto_ptr
{
public:...auto_ptr(auto_ptr<T>& rhs);auto_ptr<T>& operator = (auto_ptr<T>& rhs);...
};							template<class T>
auto_ptr<T>::auto_ptr(auto_ptr<T>& rhs)
{pointee = rhs.pointee;  //将*pointee的拥有权转移至*thisrhs.pointee = 0;		//rhs不再拥有任何东西
}template<class T>
auto_ptr<T>& auto_ptr<T>::operator = (auto_ptr<T>& rhs)
{if(this = &rhs)return *this;delete pointee; //必须删除目前拥有之物pointee = rhs.pointee;rhs.pointee = 0;return *this;
}

由于auto_ptr的复制构造函数被调用时，对象拥有权转移了，所以以by value方式传递auto_ptrs绝对不合适，Pass-by-refrence-to-const才是适当的途径。

void printTreeNode(ostream& s,auto_ptr<TreeNode> p)
{s << *p;
}int main()
{auto<TreeNode> ptn(new TreeNode);...printTreeNode(cout,ptn); //以by value方式传递auto_ptr
}//Pass-by-refrence-to-const方式
void printTreeNode(ostream& s, const auto_ptr<TreeNode>& p)
{s << *p;
}

实现Dereferencing Operators（解引操作符）

smart pointers的核心：operator*和operator->函数

//operator*
template<class T>
T& SmartPtr<T>::operator*() const
{///perform "smart pointer" processing;return *pointee;
}
//返回值是reference形式

//operator->
void editTuple(DBPtr<Tuple>& pt)
{LogEntry<Tuple> entry(*pt);do{pt->displayEditDialog();//会被编译器解释为(pt.operator->())->displayEditDialog();}while (pt->isValid == false)
}
//大部分时候想要operator->返回一个普通的dump pointer：
template<class T>
T* SmartPtr<T>::operator->() const
{//perform "smart pointer" processing;return pointee;
}

测试Smart Pointers是否为NULL

为smart pointer classes加上一个isNull函数很容易，但smart pointers 无法像dumb pointers那般自然地测试是否为null：

SmartPtr<TreeNode> ptn;
...
if(ptn == 0) ... //错误
if(ptn) ...		 //错误
if(!ptn) ...	 //错误

提供一个类型转换操作符，允许上述动作得以通过编译：

template<class T>
class SmartPtr
{
public:...operator void*(); //如果dumb ptr是null，返回零//否则返回非零值
};SmartPtr<TreeNode> ptn;
...
if(ptn == 0) ... //ok
if(ptn) ...		 //ok
if(!ptn) ...	 //ok

缺点：允许你把smart pointers拿来和完全不同的类型做比较：

SmartPtr<Apple> pa;
SmartPtr<Orange> po;
...
if(pa == po)  //竟然可以过关//重载“！操作符”
template<class T>
class SmartPtr
{
public:...bool operator!() const; //只有当smart ptr是null才返回true...
};//clients：
SmartPtr<TreeNode> ptn;
...
if(!ptn)
{...		
}else{...
}if(ptn == 0) ... 	//错误
if(ptn) ... 		//错误//唯一的风险：
SmartPtr<Apple> pa;
SmartPtr<Orange> po;
...
if(!pa == !po)	//竟然可通过编译

C++标准库中，“隐式转换为void*”已被“隐式转换为bool”取代，而operator bool总是返回operator！的反相。

将Smart Pointers转换为Dumb Pointers

如果为smart pointer-to-T template加上一个隐式类型转换函数，便可转换为dumb pointer-to-T：

Template<class T>
class DBPtr
{
public:...operator T*() const;  //新增的转换操作符...
};DBPtr<Tuple> pt;
...
normalize(pt);			//现在这就成功了//nullness测试问题也一并解决了：
if(ptn == 0) ... //可以
if(ptn) ...		 //可以
if(!ptn) ...	 //可以

与设计smart pointer目的相违背！也不要提供对dumb pointer的隐式转换操作符，除非不得已！

Smart Pointers和“和继承有关的”类型转换

我们真正想要知道的是如何能够将“smart pointers classes的行为”在“与继承相关类型转换”上，能够和dumb pointers一样。答案很简单：不能够。
smart pointers虽然smart，却不是pointers，我们所能做的最好情况就是使用member templates来产生转换函数，然后再在其中出现模棱两可的时候使用转型动作。

Smart Pointers 与 const

smart pointers中const只能施行于指针身上，不能用于其所指的对象；

类型转换如果涉及const，便是一条单行道：从non-const 转换成const是安全的，从const 转换成non-const则不安全。此外，能够对const做的任何事情，也都可以对non-const指针进行。

和public inheritance的规则类似，可以利用：
实现smart pointers时令一个smart pointer-to-T class公开继承一个对应的smart pointer-to-const-T class:

template<class T>
class SmartPtrToConst
{
public:... 					//一般都会有smart pointer member//functionsprotected:union{const T* constPointee;	 //给SmartPtrToConst使用T* pointee;				 //给SmartPtr使用};
};template<class T>
class SmartPtr:public SmartPtrToConst<T>
{...		  					//没有data members
}