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

Smart Pointers智能指针

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

1. 构造和析构；
2. 复制和赋值；
3. 解引。

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的拥有权转移至*this
	rhs.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
		//functions
		
protected:
	union{
		const T* constPointee;	 //给SmartPtrToConst使用
		T* pointee;				 //给SmartPtr使用
	};
};
 
template<class T>
class SmartPtr:public SmartPtrToConst<T>
{
	...		  					//没有data members
}