C++智能指针思想

一、智能指针思想

1、智能指针是一个类模板；

2、通过构造函数接管申请的内存；

3、通过析构函数释放申请的内存；

4、通过重载指针运算符->和*来模拟指针的行为；

5、通过重载比较运算符==和 !=来模拟指针的比较；

二、智能指针分类

1、不带引用计数的智能指针

1. auto_ptr
2. unique_ptr
3. scoped_ptr

2、带引用计数的智能指针

1. weak_ptr
2. shared_ptr

三、简单的智能指针

template<typename T>
class SmartPointer
{
public:
    SmartPointer()
    {
        this->p = NULL;
    }
    SmartPointer(T *p)
    {
        this->p = p;
    }
    ~SmartPointer()
    {
        delete p;
    }

    T *operator->()
    {
        return p;
    }

    T &operator*()
    {
        return *p;
    }

private:
    T *p;
};

四、auto_ptr

template <typename T>
class AutoPtr
{
public:
    AutoPtr(T *_ptr):ptr(_ptr)
    {
    }
    AutoPtr(const AutoPtr<T>& a):ptr(_ptr)
    {
        a.ptr = NULL;
    }
    AutoPtr<T>& opetator=(AutoPtr<T>& a)
    {
        if(this != &a)
        {
            delete ptr;
            ptr = a.ptr;
            a.ptr = NULL;
        }
        return *this;
    }

    ~AutoPtr()
    {
        delete ptr;
    }

    T& operator*()
    {
        return *ptr;
    }

    T* operator->()
    {
        return ptr;
    }

private:
    T *ptr;
};

五、share_ptr

template<class T>
class Share_ptr
{
    //friend class Weak_ptr<T>; 
public:
    Share_ptr(T *_ptr):ptr(_ptr),pCount(new int(1))
    {
    }

    Share_ptr(const Share_ptr<T>& s)
        :ptr(s.ptr), pCount(s.pCount)
    {
        ++(*pCount);
    }

    ~Share_ptr()
    {
        if(*pcount == 1)
        {
            delete ptr;
            delete pCount;
        }
        else
        {
            --(*pCount);
        }
    }

    Share_ptr<T>& operator=(const Share_ptr<T>& s)
    {
        if(ptr != s.ptr)
        {
            if(--(*pCount) == 0)
            {
                if(ptr)
                {
                    delete ptr;
                }
                delete pCount;
            }
            ptr = s.ptr;
            pCount = s.pCount;
            ++(*pCount);
        }
        return *this;
    }

    T& operator*()
    {
        return *ptr;
    }

    T* operator->()
    {
        return ptr;
    }

private:
    T *ptr;
    int *pCount;
};