wordpress page页面id成都网站seo服务
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
}