智能指针是一种类，别名称为句柄类

引子：智能指针是不是指针？

看C++ primer时，一直心存这样的疑问？

而在面向对象里面提及到一种概念-智能指针，而往往同学会出现以下的问题

【问题】

　　 智能指针是不是一种指针？

　　stl里面的智能指针是什么？

【回答】

　　 智能指针是一种类，别名称为句柄类。而这种类型恰恰是《设计模式》中的代理模式、适配器模式（这两种模式以后会在MyBlog的相关文章介绍）。

　　stl里面的智能指针同样也不是指针！是一种类型！

----------------------------------------------

句柄及智能指针

1、句柄

句柄，英文：HANDLE，在Windows编程中是一个很重要的概念，在许多地方都扮演着重要的角色。但由此而产生的句柄概念也大同小异，比如：《Microsoft Windows 3 Developer's Workshop》（MicrosoftPress,by Richard Wilton）一书中句柄的概念是：在Windows环境中，句柄是用来标识项目的。句柄这个概念主要来源与windows，就其意义而言在不同的地方有些差异。

Windows中的句柄句柄，是整个windows编程的基础。一个句柄是指使用的一个唯一的整数值，即一个四字节长的数值，来标志应用程序中的不同对象和同类对象中的不同的实例，诸如，一个窗口，按钮，图标，滚动条，输出设备，控件或者文件等。应用程序能够通过句柄访问相应的对象的信息，但是句柄不是一个指针，程序不能利用句柄来直接阅读文件中的信息。如果句柄不用在I/O文件中，它是毫无用处的。 句柄是windows用来标志应用程序中建立的或是使用的唯一整数，windows使用了大量的句柄来标志很多对象。

在程序设计中，句柄是一种特殊的智能指针。当一个应用程序要引用其他系统（如数据库、操作系统）所管理的内存块或对象时，就要使用句柄。

句柄与普通指针的区别在于，指针包含的是引用对象的内存地址，而句柄则是由系统所管理的引用标识，该标识可以被系统重新定位到一个内存地址上。这种间接访问对象的模式增强了系统对引用对象的控制。

2、智能指针及与句柄的联系

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

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

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

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

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

class TestPtr

{

public:

TestPtr(int *p): ptr(p) { }

~TestPtr( ) { delete ptr; }

// other operations

private:

int *ptr;

// other data

};

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

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

方案一、单独类

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

class RefPtr

{

friend class TestPtr;

int *ptr;

size_tcount;

RefPtr (int *p): ptr(p), count(1) {}

~RefPtr () {

delete ptr;

}

};

class TestPtr

{

public:

TestPtr(int *p): ptr(new RefPtr(p)) { }

TestPtr(const TestPtr& src): ptr(src.ptr) {

++ptr->count;

}

TestPtr& operator= (const TestPtr& rhs) {

// self-assigning is also right

++rhs.ptr->count;

if (--ptr->count == 0)

delete ptr;

ptr = rhs.ptr;

return *this;

}

~TestPtr() {

if (--ptr->count == 0)

delete ptr;

}

private:

RefPtr *ptr;

};

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

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

方案二、使用句柄类

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

#include <iostream>

#include <stdexcept>

using namespace std;

#define TEST_SMARTPTR

class Stub

{

public:

void print() {

cout<<"Stub: print"<<endl;

}

~Stub(){

cout<<"Stub: Destructor"<<endl;

}

};

template <typename T>

class SmartPtr

{

public:

SmartPtr(T *p = 0): ptr(p), pUse(newsize_t(1)) { }

SmartPtr(const SmartPtr& src): ptr(src.ptr), pUse(src.pUse){

++*pUse;

}

SmartPtr& operator= (const SmartPtr& rhs) {

// self-assigning is also right

++*rhs.pUse;

decrUse();

ptr = rhs.ptr;

pUse = rhs.pUse;

return *this;

}

T *operator->() {

if (ptr)

return ptr;

throw std::runtime_error("access through NULLpointer");

}

const T *operator->() const {

if (ptr)

return ptr;

throw std::runtime_error("access through NULLpointer");

}

T &operator*() {

if (ptr)

return *ptr;

throw std::runtime_error("dereference of NULLpointer");

}

const T &operator*() const {

if (ptr)

return *ptr;

throw std::runtime_error("dereference of NULLpointer");

}

~SmartPtr() {

decrUse();

#ifdef TEST_SMARTPTR

std::cout<<"SmartPtr: Destructor"<<std::endl;// for testing

#endif

}

private:

void decrUse() {

if (--*pUse == 0) {

delete ptr;

delete pUse;

}

}

T *ptr;

size_t*pUse;

};

int main()

{

try {

SmartPtr<Stub> t;

t->print();

} catch (const exception& err) {

cout<<err.what()<<endl;

}

SmartPtr<Stub> t1(new Stub);

SmartPtr<Stub> t2(t1);

SmartPtr<Stub> t3(new Stub);

t3 = t2;

t1->print();

(*t3).print();

return 0;

}