智能指针(1)

C++

参考：百度百科

概念

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

原理

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

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

实现引用计数有两种经典策略：一是引入辅助类，二是使用句柄类。

方案一

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

这种技术的一个实例为：写时拷贝（Copy-On-Write）

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

示例代码如下：

class RefPtr
{
    friend class TestPtr;
    int*ptr;
    size_t count;
    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){
            ++rhs.ptr->count;
            if(--ptr->count==0)
                delete ptr;
            ptr=rhs.ptr;
            return *this;
        }
        ~TestPtr(){
            if(--ptr->count==0)
                delete ptr;
        }
    private:
        RefPtr* ptr;
};

方案二

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

实现示例如下：

#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(new size_t(1)){}
        SmartPtr(const SmartPtr &src):ptr(src.ptr),pUse(src.pUse){
            ++*pUse;
        }
        SmartPtr& operator=(const SmartPtr &rhs){
            ++*rhs.pUse;
            decrUse();
            ptr=rhs.ptr;
            pUse=rhs.pUse;
            return *this;
        }
        // as right value
        T* operator->(){
            if(ptr)
                return ptr;
            throw std::runtime_error("access through NULL pointer");
        }
        // as left value
        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;//fortesting
#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;
}