引用计数实现智能指针

只能指针实现了指针指向对象的共享。同时避免了悬垂指针等问题。

通过对运算符的重载它可以像普通指针一样的操作。只要有一个智能指针指向

这个对象，那么这个对象就不会被释放掉。

#include<iostream>
#include<iomanip>
#include<list>
#include<cmath>
#include<vector>
using namespace std;
// 引用计数实现智能指针
template<typename T>
class U_Ptr
{
    size_t use;
    T *ip;
    U_Ptr(T *p):ip(p),use(1){}
    template<typename T>
    friend class HasPtr;
    ~U_Ptr(){delete ip;}
};

template<typename T>
class HasPtr
{
private:
    U_Ptr<T>  *ptr;
public:
    HasPtr(T *p):ptr(new U_Ptr<T>(p)){}
    HasPtr(const HasPtr &h)
    {
        h.ptr->use++;
        ptr=h.ptr;
    }
    HasPtr& operator=(const HasPtr &h)
    {
        h.ptr->use++;
        if(--ptr->use==0)
            delete ptr; 
        ptr=h.ptr;
    }
    ~HasPtr()
    {
        ptr->use--;
        if(ptr->use==0)
            delete ptr;
    }
    T *operator->()
    {
        return ptr->ip;
    }
    T operator*()
    {
        return *ptr->ip;
    }
    size_t getCount()
    {
        return ptr->use;
    }
};
void main()
{ 
    int *p=new int(10);
    HasPtr<int> ptr(p);
    {
        
        HasPtr<int> ptr1=ptr;
        HasPtr<int> ptr2=ptr1,ptr3=ptr;
        cout<<"Count:"<<ptr3.getCount()<<" value:"<<*ptr3<<endl;
    }
    cout<<"Count:"<<ptr.getCount()<<" value:"<<*ptr<<endl;
    

    system("pause");
}