智能指针

当类中有 指针 成员时，一般有两种方式来管理 指针 成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。

智能 指针(smart pointer)的一种通用实现技术是使用 引用计数(reference count)。智能 指针类将一个计数器与类指向的对象相关联， 引用计数跟踪该类有多少个对象共享同一指针。

目录

1原理

2智能指针

1原理编辑

每次创建类的新对象时，初始化指针并将 引用计数置为1；当对象作为另一对象的副本而创建时， 拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左 操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用 析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。

实现 引用计数有两种经典策略：一是引入辅助类，二是使用 句柄类。下面分别介绍这些内容

问题描述

假设有一个名为TestPtr的类，里面有一个 指针成员，简化为如下代码

1 2 3 4 5 6 7 8 9 10

classTestPtr { public : TestPtr( int *p):ptr(p){} ~TestPtr(){deleteptr;} //otheroperations private : int *ptr; //otherdata };

在这种情况下，类TestPtr对象的任何拷贝、赋值操作都会使多个TestPtr对象共享相同的 指针。但在一个对象发生析构时， 指针指向的对象将被释放，从而可能引起 悬垂指针。

现在我们使用 引用计数来解决这个问题，一个新的问题是引用计数放在哪里。显然，不能放在TestPtr类中，因为多个对象共享 指针时无法同步更新 引用计数。

方案一

这里给出的解决方案是，定义一个单独的具体类（RefPtr）来封装 指针和相应的 引用计数。由于这个类只是用于对类TestPtr中的 成员指针ptr进行了封装，无其它用途，所以把 引用计数类RefPtr的所有成员均定义为private，并把类TestPtr声明为它的友元类，使TestPtr类可以访问RefPtr类。示例代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

classRefPtr { friendclassTestPtr; int *ptr; size_tcount; RefPtr( int *p):ptr(p),count(1){} ~RefPtr(){ deleteptr; } }; classTestPtr { public : TestPtr( int *p):ptr(newRefPtr(p)){} TestPtr(constTestPtr&src):ptr(src.ptr){ ++ptr->count; } TestPtr&operator=(constTestPtr&rhs){ //self-assigningisalsoright ++rhs.ptr->count; if (--ptr->count==0) deleteptr; ptr=rhs.ptr; return * this ; } ~TestPtr(){ if (--ptr->count==0) deleteptr; } private : RefPtr*ptr; };

当希望每个TestPtr对象中的 指针所指向的内容改变而不影响其它对象的指针所指向的内容时，可以在发生修改时，创建新的对象，并修改相应的 引用计数。这种技术的一个实例就是写时拷贝（Copy-On-Write）。

这种方案的缺点是每个含有 指针的类的实现代码中都要自己控制 引用计数，比较繁琐。特别是当有多个这类 指针时，维护 引用计数比较困难。

方案二

为了避免上面方案中每个使用 指针的类自己去控制 引用计数，可以用一个类把 指针封装起来。封装好后，这个类对象可以出现在用户类使用 指针的任何地方，表现为一个指针的行为。我们可以像 指针一样使用它，而不用担心普通 成员指针所带来的问题，我们把这样的类叫 句柄类。在封装句柄类时，需要申请一个动态分配的 引用计数空间，指针与引用计数分开存储。实现示例如下

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

#include<iostream> #include<stdexcept> usingnamespacestd; #defineTEST_SMARTPTR classStub { public : voidprint(){ cout<< "Stub:print" <<endl; } ~Stub(){ cout<< "Stub:Destructor" <<endl; } }; template <typenameT> classSmartPtr { public : SmartPtr(T*p=0):ptr(p),pUse(newsize_t(1)){} SmartPtr(constSmartPtr&src):ptr(src.ptr),pUse(src.pUse){ ++*pUse; } SmartPtr&operator=(constSmartPtr&rhs){ //self-assigningisalsoright ++*rhs.pUse; decrUse(); ptr=rhs.ptr; pUse=rhs.pUse; return * this ; } T*operator->(){ if (ptr) returnptr; throwstd::runtime_error( "accessthroughNULLpointer" ); } constT*operator->() const { if (ptr) returnptr; throwstd::runtime_error( "accessthroughNULLpointer" ); } T&operator*(){ if (ptr) return *ptr; throwstd::runtime_error( "dereferenceofNULLpointer" ); } constT&operator*() const { if (ptr) return *ptr; throwstd::runtime_error( "dereferenceofNULLpointer" ); } ~SmartPtr(){ decrUse(); #ifdefTEST_SMARTPTR std::cout<< "SmartPtr:Destructor" <<std::endl; //fortesting #endif } private : voiddecrUse(){ if (--*pUse==0){ deleteptr; deletepUse; } } T*ptr; size_t *pUse; }; intmain() { try { SmartPtr<Stub>t; t->print(); } catch (constexception&err){ cout<<err.what()<<endl; } SmartPtr<Stub>t1(newStub); SmartPtr<Stub>t2(t1); SmartPtr<Stub>t3(newStub); t3=t2; t1->print(); (*t3).print(); return0; }

2智能指针编辑

智能 指针是存储指向动态分配（堆） 对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置 指针。智能 指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。

事实上，智能 指针能够做的还有很多事情，例如处理 线程安全，提供写时复制，确保协议，并且提供远程交互服务。有能够为这些ESP (Extremely Smart Pointers)创建一般智能 指针的方法，但是并没有涵盖进来。

智能 指针的大部分使用是用于生存期控制，阶段控制。它们使用operator->和operator*来生成原始 指针，这样智能指针看上去就像一个普通指针。

这样的一个类来自标准库：std:: auto_ptr。它是为解决资源所有权问题设计的，但是缺少对引用数和 数组的支持。并且，std:: auto_ptr在被复制的时候会传输所有权。在大多数情况下，你需要更多的和/或者是不同的功能。这时就需要加入smart_ptr类。

smart_ptr 类

在Boost中的智能 指针有：

。scoped_ptr，用于处理单个对象的唯一所有权；与std:: auto_ptr不同的是，scoped_ptr可以被复制。

。scoped_array，与scoped_ptr类似，但是用来处理 数组的

。 shared_ptr，允许共享对象所有权

。shared_array，允许共享 数组所有权

scoped_ptr

scoped_ptr智能 指针与std:: auto_ptr不同，因为它是不传递所有权的。事实上它明确禁止任何想要这样做的企图！这在你需要确保 指针任何时候只有一个拥有者时的任何一种情境下都是非常重要的。如果不去使用scoped_ptr，你可能倾向于使用std:: auto_ptr，让我们先看看下面的代码：

auto_ptrMyOwnString?

(new string("This is mine to keep!"));

auto_ptrNoItsMine?(MyOwnString?);

cout << *MyOwnString << endl; // Boom

这段代码显然将不能编译通过，因为字符串的所有权被传给了NoItsMine。这不是std:: auto_ptr的设计缺陷—而是一个特性。尽管如此，当你需要MyOwnString达到上面的代码预期的工作效果的话，你可以使用scoped_ptr：

scoped_ptr MyOwnString?

(new string("This is mine to keep for real!"));

// Compiler error - there is no copy constructor.

scoped_ptr TryingToTakeItAnyway?

(MyOwnString?);

scoped_ptr通过从boost::noncopyable继承来完成这个行为（可以查看Boost.utility库）。不可复制类声明 复制构造函数并将赋值操作符声明为private类型。

scoped_array

scoped_array与scoped_ptr显然是意义等价的，但是是用来处理数组的。在这一点标准库并没有考虑—除非你当然可以使用std::vector，在大多数情况下这样做是可以的。

用法和scoped_ptr类似：

typedef tuples::tupleint> ArrayTuple?;

scoped_array MyArray?(new ArrayTuple?[10]);

tuples::get<0>(MyArray?[5]) ="The library Tuples is also part of Boost";

tuple是元素的集合—例如两倍，三倍，和四倍。Tuple的典型用法是从函数返回多个值。Boost Tuple库可以被认为是标准库两倍的扩展，目前它与近10个tuple元素一起工作。支持tuple流，比较，赋值，卸包等等。

当scoped_array越界的时候，delete[]将被正确的调用。这就避免了一个常见错误，即是调用错误的操作符delete。

shared_ptr

这里有一个你在标准库中找不到的—引用数智能 指针。大部分人都应当有过使用智能 指针的经历，并且已经有很多关于引用数的文章。最重要的一个细节是引用数是如何被执行的—插入，意思是说你将 引用计数的功能添加给类，或者是非插入，意思是说你不这样做。Boost shared_ptr是非插入类型的，这个实现使用一个从堆中分配来的引用计数器。关于提供参数化策略使得对任何情况都极为适合的讨论很多了，但是最终讨论的结果是决定反对聚焦于可用性。可是不要指望讨论的结果能够结束。

shared_ptr完成了你所希望的工作：他负责在不使用实例时删除由它指向的对象（pointee），并且它可以自由的共享它指向的对象（pointee）。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

voidPrintIfString?(constany&Any){ if (constshared_ptr*s= any_cast>(&Any)){ cout<<**s<<endl; } } intmain(intargc, char *argv[]) { std::vectorStuff; shared_ptrSharedString1? (newstring("Shareme.Bytheway, Boost.anyisanotherusefulBoost library")); shared_ptrSharedString2? (SharedString1?); shared_ptrSharedInt1? (newint(42)); shared_ptrSharedInt2? (SharedInt1?); Stuff.push_back(SharedString1?); Stuff.push_back(SharedString2?); Stuff.push_back(SharedInt1?); Stuff.push_back(SharedInt2?); //Printthestrings for_each(Stuff.begin(),Stuff.end(), PrintIfString?); Stuff.clear(); //Thepointeesoftheshared_ptr's //willbereleasedonleavingscope //shared_ptr的pointee离开这个范围后将被释放 return0; }

any库提供了存储所有东西的方法[2]HYPERLINK "file:///C:Documents%20and%20SettingsAdministrator 桌面My%20Documents新建 CUJhtml20.04karlsson%22%20l"[4]。在包含类型中需要的是它们是可拷贝构造的（CopyConstructible）， 析构函数这里绝对不能引发，他们应当是可赋值的。我们如何存储和传递“所有事物”？无区别类型（读作void*）可以涉及到所有的事物，但这将意味着将 类型安全（与知识）抛之脑后。any库提供 类型安全。所有满足any需求的类型都能够被赋值，但是解开的时候需要知道解开类型。any_cast是解开由any保存着的值的钥匙，any_cast与 dynamic_cast的工作机制是类似的— 指针类型的类型转换通过返回一个空指针成功或者失败，因此赋值类型的类型转换抛出一个异常(bad_any_cast)而失败。

shared_array

shared_array与 shared_ptr作用是相同的，只是它是用于处理数组的。

shared_array MyStrings?( new Base[20] );

深入shared_ptr实现

创建一个简单的智能 指针是非常容易的。但是创建一个能够在大多数 编译器下通过的智能 指针就有些难度了。而创建同时又考虑异常安全就更为困难了。Boost:: shared_ptr这些全都做到了，下面便是它如何做到这一切的。（请注意：所有的include，断开 编译器处理，以及这个实现的部分内容被省略掉了，但你可以在Boost.smart_ptr当中找到它们）。

首先，类的定义：很显然，智能 指针是（几乎总是）模板。

template class shared_ptr{

公共接口是：

explicit shared_ptr(T* p =0) : px(p) {// fix: prevent leak if new throwstry { pn = new long(1); }catch (...) { checked_delete(p); throw; }}

现在看来，在 构造函数当中两件事情是容易被忽略的。 构造函数是explicit的，就像大多数的构造函数一样可以带有一个参数。另外一个值得注意的是引用数的堆分配是由一个try-catch块保护的。如果没有这个，你得到的将是一个有缺陷的智能 指针，如果引用数没有能够成功分配，它将不能正常完成它自己的工作。

~ shared_ptr() { dispose(); }

析构函数执行另外一个重要任务：如果引用数下降到零，它应当能够安全的删除指向的对象（pointee）。 析构函数将这个重要任务委托给了另外一个方法：dispose。

void dispose() { if (—*pn == 0)

{ checked_delete(px); delete pn; } }

正如你所看到的，引用数（pn）在减少。如果它减少到零，checked_delete在所指对象 (px)上被调用，而后引用数(pn)也被删除了。

那么，checked_delete执行什么功能呢？这个便捷的函数（你可以在Boost.utility中找到）确保 指针代表的是一个完整的类型。在你的智能 指针类当中有这个么？

这是第一个 赋值运算符：

template shared_ptr& operator=(const shared_ptr& r) {return *this;}

这是成员模版,如果不是这样，有两种情况：

1. 如果没有参数化 复制构造函数，类型赋值Base = Derived无效。

2. 如果有参数化 复制构造函数，类型赋值将生效，但同时创建了一个不必要的临时smart_ptr。

这再一次的展示给你为什么不应当加入你自己的智能 指针的一个非常好的原因—这些都不是很明显的问题。

赋值运算符的实际工作是由share函数完成的：

1 2 3 4 5 6 7 8 9 10 11

voidshare(T*rpx, long *rpn){ if (pn=rpn){ //Q:whynotpx=rpx? //A:failswhenboth==0 ++*rpn; //donebeforedispose()incase //rpntransitivelydependenton //*this(bugreportedbyKenJohnson) dispose(); px=rpx; pn=rpn; } }

需要注意的是自我赋值（更准确地说是自我共享）是通过比较引用数完成的，而不是通过 指针。为什么这样呢？因为它们两者都可以是零，但不一定是一样的。

template shared_ptr

(const shared_ptr& r) : px(r.px) { // never throws

++*(pn =r.pn);

}

这个版本是一个模版化的拷贝构造和函数。可以看看上面的讨论来了解为什么要这样做。

赋值运算符以及赋值 构造函数在这里同样也有一个非模版化的版本：

shared_ptr(const shared_ptr& r) :

// never throws

px(r.px) { ++*(pn =r.pn); }

shared_ptr& operator=

(const shared_ptr& r) {

share(r.px,r.pn);

return *this;

}

reset函数就像他的名字那样，重新设置所指对象（pointee）。在将要离开作用域的时候，如果你需要销毁所指对象（pointee）它将非常方便的帮你完成，或者简单的使缓存中的值失效。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

voidreset(T*p=0){ //fix:self-assignmentsafe if (px==p) return ; if (—*pn==0) {checked_delete(px);} else { //allocatenewreference //counter //fix:preventleakifnewthrows try {pn=newlong;} catch (...){ //undoeffectof—*pnaboveto //meeteffectsguarantee ++*pn; checked_delete(p); throw ; } //catch } //allocatenewreferencecounter *pn=1; px=p; } //reset

这里仍然请注意避免潜在的内存泄漏问题和保持异常安全的处理手段。

这样你就有了使得智能 指针发挥其“智能”的运算符：

// never throws

T& operator*() const { return *px; }

// never throws

T* operator->() const { return px; }

// never throws

T* get() const { return px; }

这仅仅是一个注释：有的智能 指针实现从类型转换 运算符到T*的转换。这不是一个好主意，这样做常会使你因此受到伤害。虽然get在这里看上去很不舒服，但它阻止了 编译器同你玩游戏。

我记得是Andrei Alexandrescu说的：“如果你的智能 指针工作起来和哑指针没什么两样，那它就是哑指针。”简直是太对了。

这里有一些非常好的函数，我们就拿它们来作为本文的结束吧。

long use_count() const

{ return *pn; } // never throws

bool unique() const

{ return *pn == 1; } // never throws

函数的名字已经说明了它的功能了，对么？

关于Boost.smart_ptr还有很多应当说明的（比如std::swap和std::less的特化，与std:: auto_ptr榜定在一起确保 兼容性以及便捷性的成员，等等），由于篇幅限制不能再继续介绍了。详细内容请参考Boost distribution ()的smart_ptr.hpp。即使没有那些其它的内容，你不认为他的确是一个非常智能的 指针么？