C++中智能指针的设计和使用

http://blog.csdn.net/hackbuteer1/article/details/7561235

智 能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是 使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
    智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。当然，智能 指针还不止这些，还包括复制时可以修改源对象等。智能指针根据需求不同，设计也不同（写时复制，赋值即释放对象拥有权限、引用计数等，控制权转移等）。 auto_ptr 即是一种常见的智能指针。

大多数C++类用三种方法之一管理指针成员
    （1）不管指针成员。复制时只复制指针，不复制指针指向的对象。当其中一个指针把其指向的对象的空间释放后，其它指针都成了悬浮指针。这是一种极端
    （2）当复制的时候，即复制指针，也复制指针指向的对象。这样可能造成空间的浪费。因为指针指向的对象的复制不一定是必要的。
   （3） 第三种就是一种折中的方式。利用一个辅助类来管理指针的复制。原来的类中有一个指针指向辅助类，辅助类的数据成员是一个计数器和一个指针（指向原来的）（此为本次智能指针实现方式）。
     其实，智能指针的引用计数类似于java的垃圾回收机制：java的垃圾的判定很简答，如果一个对象没有引用所指，那么该对象为垃圾。系统就可以回收了。

http://blog.163.com/bbluesnow@126/blog/static/27784545201222682418694/

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

C++智能指针的设计和实现

http://www.cnblogs.com/bigwangdi/archive/2013/06/15/3138123.html

智能指针通常使用类模板来实现。模拟类指针的各种行为。但是，其最重要的作用是对类指针成员的管理，防止悬垂指针的出现。

template<class T>  
class SmartPointer{  
    public:  
        SmartPointer(T *t):pt(t){}  
        T& operator *(){ return *pt; }  
        T* operator ->() { return pt; }  
    private:  
        T *pt;  
};  

三、引用计数的实现

　　为了实现引用计数，我们定义一个_counter类来记录引用次数，把_counter类的所有成员设定为private，因为其他的类型并不需要访问_counter，只有SmartPointer对其进行操作就行了，SmartPointer将设为其友元类。

class _counter{  
    template<class T> friend class SmartPointer;  
    _counter(int u):use(u){}  
    ~_counter(){}  
    int use;  
};  

在SmartPointer类中，保留_counter的指针。

template<class T>  
class SmartPointer{  
    public:  
        SmartPointer(T *t):pc(new _counter(1)){  
            cout<<"SmartPointer::SmartPointer() invoded use is: "<<pc->use<<endl;  
            this->pt = t;  
        }  
  
        SmartPointer(SmartPointer<T> &rhs){  
            this->pc = rhs.pc;  
            this->pt = rhs.pt;  
            this->pc->use++;  
            cout<<"SmartPointer copy invoked use is: "<<pc->use<<endl;  
        }  
  
        ~SmartPointer(){  
            pc->use--;  
            cout<<"SmartPointer::~SmartPointer() invoded use is: "<<pc->use<<endl;  
            if(pc->use == 0)  
            {  
                delete pt;  
                delete pc;  
            }  
        }  
  
        SmartPointer<T>& operator=(SmartPointer<T> rhs){  
            if(rhs == *this){  
                return *this;  
            }  
  
            this->pt = rhs.pt;  
            this->pc = rhs.pc;  
            this->pc->use++;  
            cout<<"SmartPointer::operator=() invoked  use is: "<<pc->use<<endl;  
            return *this;  
        }  
  
    private:  
        T *pt;  
        _counter* pc;  
};  

例如：我们有一个HasPtr类，其类成员中有一个为指针*p。

class HasPtr{  
    public:  
        HasPtr(int val):value(val),p(new int(3)){  
            cout<<"HasPtr::HasPtr() invoked"<<endl;  
        }  
        ~HasPtr(){ delete p; cout<<"HasPtr::~HasPtr() invoded"<<endl;}  
  
    private:  
        int *p;  
        int value;  
};  

如果如下调用：

HasPtr *php = new HasPtr(3);  
SmartPointer<HasPtr> psp(php);  
SmartPointer<HasPtr> npsp(psp);

我们现在有两个智能指针对象，指向同一个HasPtr对象，其模型如下：

_counter的use成员（引用计数）为2.

四、测试

int main(void)  
{  
    HasPtr *php = new HasPtr(3);  
    SmartPointer<HasPtr> psp(php);  
    SmartPointer<HasPtr> npsp(psp);  
    SmartPointer<HasPtr> nnpsp = npsp;  
  
  
    return 0;  
}