C++-智能指针——简单实现分析

一：为什么要有智能指针

在我们动态开辟内存时，每次new完就一定会有配套的delete来完成释放操作。可是这时候问题就来了，有时候程序未必会执行到我们释放的那一步，说不定在中间部分就进行了异常的跳转又或者是在判断是否释放的条件上出错，都会导致未按照我们预想的那样完成空间的释放，从而造成内存泄漏。

这时候就有人利用ＲＡＩＩ思想实现了智能指针，所以说白了所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。而所谓的智能主要就是利用类的默认成员函数中的析构函数的特性。

---

二：智能指针的发展历史

---

二：各类智能指针的核心思想以及简单实现

---

<1>auto_ptr

核心思想实现如下：

//自动指针，管理权限转移
template <class T>
class AutoPtr
{
public:
    AutoPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~AutoPtr()
    {
        cout << "~AutoPtr()" << endl;
        delete _ptr;
    }

    AutoPtr(AutoPtr<T>& ap)
        :_ptr(ap._ptr)
    {
        ap._ptr = NULL;
    }

    AutoPtr<T>& operator=(AutoPtr<T>& ap)
    {
        if (_ptr != ap._ptr)
        {
            if (_ptr)
            {
                delete _ptr;
            }
            _ptr = ap._ptr;
            ap._ptr = NULL;
        }
        return *this;
    }

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

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

private:
    T* _ptr;
};

当我们进行简单的操作并不会出现问题：

但是！由于auo_ptr核心思想是管理权限转移，当有新的指针进行拷贝构造或者赋值时，就会剥夺旧指针的管理权，将旧指针置空，所以当我们再次访问旧指针时，就会报错，然而这并不是我们所期待的。

---

<2>scoped_ptr

在auto_ptr的基础上，我们就会发现只有进行拷贝构造或者赋值运算时，再次对旧指针操作就会出错，所以scoped_ptr索性直接就不让用户在使用的时候进行这两个操作，也就避免了之后错误的发生。至于实现：要想根本不让拷贝和赋值，①可以只声明不定义，这样只要用户调就会报错；②将声明放入私有中，防止定义。当完成后，用户再次调用时就会报：无法访问 private 成员(在“ScopedPtr”类中声明)的错误。

核心思想实现如下：

//守卫指针。防止拷贝
template <class T>
class ScopedPtr
{
public:
    ScopedPtr(T* ptr)
        :_ptr(ptr)
    {}

    ~ScopedPtr()
    {
        if (_ptr)
        {
            delete _ptr;
            cout << "   ~ScopedPtr()" << endl;
        }
    }

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

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


private:
    ScopedPtr(const ScopedPtr<T>& ptr);
    ScopedPtr<T>& operator=(ScopedPtr<T>& ptr);

protected:
    T* _ptr;
};

我们不使用拷贝功能的时候还好，但是我们一旦真的需要使用带拷贝功能的智能指针时，这时候就需要引入shared_ptr了。

---

<3>shaered_ptr

在我们真正想完成指针拷贝或者赋值时，真正的想法是让两个指针同时指向一片空间，而不是像auto_ptr那样的管理权转移，这时候就有一种解决办法是加入引用计数。

核心思想实现如下：

//引入引用计数
template <class T>
class SharedPtr
{
public:
    SharedPtr(T* sp)
        :_ptr(sp)
        ,_count(new int(1)) //在初始化时置1
    {}

    ~SharedPtr()
    {
        cout << "~SharedPtr()" << endl;
        Release();
    }

    SharedPtr(SharedPtr<T>& sp)
        :_ptr(sp._ptr)
        ,_count(sp._count)
    {
        (*_count)++;
    }

    SharedPtr<T>& operator= (SharedPtr<T>& sp)
    {
        if (_ptr != sp._ptr)
        {
            Release();
            _ptr = sp._ptr;
            _count = sp._count;
            (*_count)++;
        }
        return *this;
    }

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

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

    void Release()
    {
        if (--(*_count) == 0)
        {
            delete _ptr;
            delete _count;
            _ptr = NULL;
            _count = NULL;
        }
    }

    int GetCount()//获取count
    {
        return *_count;
    }

    T* GetPtr() const//获取指针
    {
        return _ptr;
    }

protected:
    T* _ptr;
    int* _count;
};

简单的测试后，发现确实引入引用计数后，解决了拷贝的问题。但是有一个缺陷，就是循环引用问题处理。

---

<4>weak_ptr

首先我们先来分析下循环引用的问题，既然weak_ptr是用来解决shared_ptr的缺陷，那就先研究下缺陷到底是什么。

上图就是简单的循环引用问题：假设所有内部的指针都是shared_ptr，在最初完成构造时，left和right指针所指向的节点计数都为1，但是当left中的next指针指向right节点时，right所指向的节点中的count++为2；同样，right的prev指针指向left所指向的节点时，left所指向的节点中count++也为2。

这时候问题就出现了！由于我们使用的指针均为shared_ptr，就会出现如下的循环逻辑：

①左侧节点要想释放，必须内部count为0，但是由于右侧节点中的_prev指针也指向该空间，导致内部计数为2，所以只有当右侧节点中的_prev指针被释放了，才能够使指向左侧节点的指针只有left一个，–count为0才能完成节点的释放；

②然而右侧节点中的_prev指针要想释放，就得先等右侧节点释放，但是右侧节点还有左侧节点中的_next指针也指向该空间，只有等左侧节点中的_next释放了，才能够完成右侧节点的释放，然后再次回到第一步逻辑。

这时候就引入了weak_ptr专门负责解决。我们只需要把节点的_next和_prev指针都改为weak_ptr，因为weak_ptr不会增加shared_ptr所指向空间的引用计数，这样在释放的时候就不会有循环引用的问题。

---

核心实现如下：

template <class T>
class WeakPtr
{
public:
    WeakPtr()
        :_ptr(NULL)
    {}

    WeakPtr(const SharedPtr<T>& sp)
        :_ptr(sp.GetPtr())
    {}

    ~WeakPtr()
    {
        if (_ptr)
        {
            cout << "~WeakPtr" << endl;
            delete _ptr;
            _ptr = NULL;
        }
    }

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

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

private:
    T* _ptr;
};

---

注：在我们平常使用时，如果是支持C++11的编译器，就可以直接包含memory库（如下），然后使用对应的函数进行操作。前提是一定要熟悉各种指针的特性。

---

小结：

1：能用智能指针来管理空间时，就尽量不出现malloc（new）或free（delete）;

2：在可以使用其他指针的前提下，拒绝使用std::auto_ptr；

3：在确定对象不会出现共享的情况下，使用boost::scoped_ptr（数组为boost::scopted-array）或c++新加的unique_ptr；

4：在确定对象出现共享的情况下，使用shared_ptr；

5：共享指针若会出现循环引用时，及时使用weak_ptr。