智能指针的模拟实现

1.引入

int main()
{
    int *p = new int;   //裸指针
    delete p;
    return 0;
}

在上面的代码中定义了一个裸指针p，需要我们手动释放。如果我们一不小心忘记释放这个指针或者在释放这个指针之前，发生一些异常，会造成严重的后果（内存泄露）。而智能指针也致力于解决这种问题，使程序员专注于指针的使用而把内存管理交给智能指针。
普通指针也容易出现指针悬挂问题，当有多个指针指向同一个对象的时候，如果某一个指针delete了这个对象，所以这个指针不会对这个对象进行操作，那么其他指向这个对象的指针呢？还在等待已经被删除的基础对象并随时准备对它进行操作。于是悬垂指针就形成了，程序崩溃也“指日可待”。

int main()
{
    int *p1 = new int(2);
    int *p2 = p1;
    int *p3 = p2;
    cout<<*p1<<endl;
    cout<<*p2<<endl;
    cout<<*p3<<endl;
    delete p1;
    cout<<*p2<<endl;
    return 0;
}

输出结果

2
2
2
-572662307

输出的结果*p2的结果并不是期待中2，因为2早已经被删除了。

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

class Test
{
public:
    Test()
    {
        cout<<"Test()"<<endl;
    }
    ~Test()
    {
        cout<<"~Test()"<<endl;
    }
    void func()
    {
        cout<<"call Test::func()"<<endl;
    }
};
template<typename T>
class CSmartptr
{
public:
    CSmartptr(T *ptr):_ptr(ptr)
    {cout<<"CSmartptr()"<<endl;}
    CSmartptr(const CSmartptr<T> &other)
    {
        _ptr = new T;
        *ptr = *other._ptr;
    }
    ~CSmartptr()
    {
        cout<<"~CSmartptr()"<<endl;
        delete _ptr;
    }
    void relase() const
    {
        ((CSmartptr<T> *)this)->owns = false;
    }
    T& operator*()
    {
        return *_ptr;
    }
    const T& operator*()const {return *_ptr;}
    T *operator->()
    {
        return _ptr;
    }
    const T *operator->()const {return _ptr;}
private:
    T *_ptr;
};
int main()
{
    CSmartptr<int> p1(new int);
    *p1 = 200;
    CSmartptr<Test> p2(new Test);
    p2->func();
    return 0;
}

1. 模拟实现auto_ptr

template<typename T>
class CSmartptr
{
public:
    CSmartptr(T *ptr):_ptr(ptr),owns(true){cout<<"CSmartptr()"<<endl;}
    CSmartptr(const CSmartptr<T> &other)
    {
        other.relase();
        _ptr = other._ptr;
    }
    ~CSmartptr()
    {
        cout<<"~CSmartptr()"<<endl;
        if( owns == true)
        {
            cout<<"~CSmartptr()"<<endl;
            delete _ptr;
        }

    }
    void relase() const
    {
        ((CSmartptr<T> *)this)->owns = false;
    }
    T& operator*()
    {
        return *_ptr;
    }
    const T& operator*()const {return *_ptr;}
    T *operator->()
    {
        return _ptr;
    }
    const T *operator->()const {return _ptr;}
private:
    T *_ptr;
    bool owns;  //标志位 ,控制一个资源的访问权限
};
int main()
{
    CSmartptr<int> p1(new int);
    *p1 = 200;
    CSmartptr<Test> p2(new Test);
    p2->func();
    return 0;
}

1. 带有引用计数的智能指针（方便对资源的管理和释放）

class CHeapTable
{
public:
    static CHeapTable& getInstance()
    {
        return mHeapTable;
    }
    //增加引用计数
    void addRef(void *ptr)
    {
        pthread_mutex_lock(mutex);
        list<Node>::iterator it = find(mList.begin(),
            mList.end(), ptr);  // Node == Node  it->mpaddr
        if(it == mList.end())
        {
            mList.push_front(ptr);
            cout<<"new addr:"<<ptr<<" ref:"<<1<<endl;
        }
        else
        {
            it->mcount++;
            cout<<"add addr:"<<ptr<<" ref:"<<it->mcount<<endl;
        }
        pthread_mutex_unlock(mutex);
    }
    //减少引用计数的
    void delRef(void *ptr)
    {
        list<Node>::iterator it = find(mList.begin(),
            mList.end(), ptr);
        if(it != mList.end())
        {
            it->mcount--;
            cout<<"del addr:"<<ptr<<" ref:"<<it->mcount<<endl;
            if(it->mcount == 0)
            {
                mList.erase(it);
            }
        }
    }
    //获取引用计数的
    int getRef(void *ptr)
    {
        list<Node>::iterator it = find(mList.begin(),
            mList.end(), ptr);
        if(it != mList.end())
        {
            return it->mcount;
        }
        return 0;
    }
private:
    CHeapTable(){}
    static CHeapTable mHeapTable;

    struct Node
    {
        Node(void *ptr=NULL):mpaddr(ptr),mcount(1){}
        bool operator==(const Node &src)
        {
            return mpaddr == src.mpaddr;
        }
        void *mpaddr; //标识堆内存资源
        int mcount; //标识资源的引用计数
    };

    list<Node> mList;
};
CHeapTable CHeapTable::mHeapTable;
template<typename T>
class CSmartPtr
{
public:
    CSmartPtr(T *ptr = NULL)
        :mptr(ptr)
    {
        if(mptr != NULL)
        {
            addRef();
        }
    }
    ~CSmartPtr()
    {
        delRef();
        if(0 == getRef())
        {
            delete mptr; 
            mptr = NULL;
        }
    }

    CSmartPtr(const CSmartPtr<T> &src)
        :mptr(src.mptr)
    {
        if(mptr != NULL)
        {
            addRef();
        }
    }

    CSmartPtr<T>& operator=(const CSmartPtr<T> &src)
    {
        if(this == &src)
            return *this;

        delRef();
        if(0 == getRef())
        {
            delete mptr;
            mptr = NULL;
        }

        mptr = src.mptr;
        if(mptr != NULL)
        {
            addRef();
        }
    }
    T& operator*(){return *mptr;}
    const T& operator*()const{return *mptr;}
    T* operator->(){return mptr;}
    const T* operator->()const{return mptr;}

    void addRef(){mHeapTable.addRef(mptr);}
    void delRef(){mHeapTable.delRef(mptr);}
    int getRef(){return mHeapTable.getRef(mptr);}
private:
    T *mptr;
     static CHeapTable &mHeapTable;
};
template<typename T>
CHeapTable& CSmartPtr<T>::mHeapTable = CHeapTable::getInstance();