自己实现智能指针

智能指针：实际指行为类似于指针的类对象 ，它的一种通用实现方法是采用引用计数的方法。

1. 智能指针将一个计数器与类指向的对象相关联，引用计数跟踪共有多少个类对象共享同一指针。
2. 每次创建类的新对象时，初始化指针并将引用计数置为1；
3. 当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；
4. 对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；这是因为左侧的指针指向了右侧指针所指向的对象，因此右指针所指向的对象的引用计数+1；
5. 调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。

class Object{};
class help{                               //辅助类
    friend class SmartPointer;
    help(Object *ptr) :hp(ptr), count(1)
    { 
        cout << "begin to create help" << endl;
    };
    ~help()
    { 
        cout << "begin to delete share" << endl;
        delete hp; 
    };

    int count;
    Object *hp;
};

class SmartPointer
{
public:
    explicit SmartPointer(Object *p) :ptr(new help(p)) //不让隐式构造
    {
        cout << "构造函数" << endl;
    }
    SmartPointer(const SmartPointer &rhs) 
    {
        this->ptr = rhs.ptr;                     
        ++rhs.ptr->count;                         //引用计数加一
        cout << "拷贝构造函数" << endl;
    }
    SmartPointer operator=(const SmartPointer &rhs)
    {
        cout << "重载=" << endl;
        ++rhs.ptr->count;             //原引用计数加一
        if (--this->ptr->count == 0)    //现引用计数减一
        {
            delete this->ptr;   
        }
        this->ptr = rhs.ptr;        
        return *this;
    }
    ~SmartPointer()
    {
        cout << "析构函数" << endl;

        if (--this->ptr->count == 0)
        {
            delete ptr;
            ptr = NULL;
        }   
    }
private:
    help *ptr;
};

int _tmain(int argc, _TCHAR* argv[])
{
//  Object *op=new Object();            
//  SmartPointer p1=op;                //构造（其实这样是错误的，因为智能指针本来只能使用直接初始化，这样的写法相当于将指针隐式转换，可能会造成两个指针同时指向一块内存而引用计数不增加）
    SmartPointer p1(new Object());    //将构造函数声明为explicit，避免上述情况发生，实际上shared_ptr的构造函数就是explicit
    SmartPointer p2(p1);               //拷贝构造

    SmartPointer p3=p2;                //拷贝构造
    p3 = p1;                          //重载等号

    return 0;
}