智能指针的实现及原理 + Good ! 句柄类_句柄类和辅助类实现智能指针-优快云博客

C++程序设计的一种常用技术——智能指针（smart pointer），主要内容包括引用计数（reference count）和句柄类(handle class)。当类中有指针成员时，一般有两种方式来管理指针成员：一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。

智能指针(smart pointer)的一种通用实现技术是使用引用计数(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类中，因为多个对象共享指针时无法同步更新引用计数。

方案一

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

[cpp] view plain copy

#include <iostream>
using namespace std;
class U_Ptr { // 计数类, 我们不希望普通用户使用，所以都为 private
private :
friend class HasPtr;
private :
U_Ptr(int *p) : ip(p), use(1) {}
~U_Ptr() {delete ip;}
int *ip;
size_t use;
};
class HasPtr {
public :
HasPtr(int *p, int i) : ptr(new U_Ptr(p)), val(i) {}
HasPtr(const HasPtr &orig) : ptr(orig.ptr), val(orig.val) {++ptr->use;}
HasPtr& operator=(const HasPtr&);
~HasPtr() {
if((--ptr->use) == 0) delete ptr;
}
private :
U_Ptr *ptr;
int val;
};
HasPtr& HasPtr::operator=(const HasPtr &rhs) {
++rhs.ptr->use;
if(--ptr->use == 0) {
delete ptr;
}
ptr = rhs.ptr;
val = rhs.val;
return *this;
}
int main() {
return 0;
}

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

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

方案二

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

#include <iostream>
#include <stdexcept>
#define BUG cout << "here\n";
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(new size_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 NULL pointer");
    }
    const T *operator->() const {
        if (ptr)
            return ptr;
        throw std::runtime_error("access through NULL pointer");
    }
    T &operator*() {
        if (ptr)
            return *ptr;
        throw std::runtime_error("dereference of NULL pointer");
    }
    const T &operator*() const {
        if (ptr)
            return *ptr;
        throw std::runtime_error("dereference of NULL pointer");
    }
    ~SmartPtr() {
        decrUse();
#ifdef TEST_SMARTPTR
        std::cout<<"SmartPtr: Destructor"<<std::endl; // for testing
#endif
    }

private:
    void decrUse() {
        --(*pUse); // 虚析构
        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;
    }
    BUG
    SmartPtr<Stub> t1(new Stub);
    SmartPtr<Stub> t2(t1);
    SmartPtr<Stub> t3(new Stub);
    BUG
    t3 = t2;
    BUG
    t1->print();
    BUG
    (*t3).print();

    return 0;
}