智能指针

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内 存、文件句柄、网络连接、互斥量等等）的简单技术。 在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在 对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做 法有两大好处：

• 不需要显式地释放资源。
• 采用这种方式，对象所需的资源在其生命期内始终保持有效。

先实现一个普通的智能指针

template<class T>
class smart_ptr
{
public:
    smart_ptr(T* ptr)
        :_ptr(ptr)
    {}

    ~smart_ptr()
    {
        if (_ptr)
        {
            delete _ptr;
            _ptr = nullptr;
        }
    }

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

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

private:
    T* _ptr;
};

即使中间有异常抛出，当作用域走完生命周期，析构函数会自动调用。完成析构，就不会发生了内存泄漏问题。

unique_ptr 基本实现

template<class T>
class unique_ptr
{
public:
    unique_ptr(T* ptr)
        :_ptr(ptr)
    {}

    ~unique_ptr()
    {
        if (_ptr)
        {
            delete _ptr;
            _ptr = nullptr;
        }
    }

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

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

    unique_ptr(unique_ptr<T>& p) = delete;
    unique_ptr<T> operator=(unique_ptr<T>& p) = delete;

private:
    T* _ptr;
};

unique_ptr跟普通智能指针区别不大  只是unique_ptr是不允许用拷贝和赋值的

shared_ptr基本实现

它能使用拷贝和赋值  使用的是一种计数的方法。

    template<class T>
    class shared_ptr
    {
    public:
        shared_ptr(T* ptr)
            :_ptr(ptr)
            , pcount(new int(1))
        {}

        ~shared_ptr()
        {
            Relses();
        }

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

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

        shared_ptr(shared_ptr<T>& p)
            :_ptr(p._ptr)
            ,pcount(p.pcount)
        {
            (*pcount)++;
        }

        void Relses()
        {
            if (--(*pcount) == 0 && _ptr)
            {
                cout << _ptr << endl;
                delete _ptr;
                delete pcount;
                _ptr = nullptr;
                pcount = nullptr;
            }
        }

        shared_ptr<T>& operator=(shared_ptr<T>& p)
        {
            if (_ptr != p._ptr)//当两个指针地址不相同才赋值
            {
                Relses();

                _ptr = p._ptr;
                pcount = p.pcount;
                *(pcount)++;
            }
            return *this;
        }

    private:
        T* _ptr;
        int* pcount;
    };