C++11新特性之智能指针

应用

当我们需要从堆上申请空间时，可以将new出来的指针交由智能指针管理，比如：shared_ptr<int> a(new int);，这样当a出作用域时，在a对象析构的时候，就会释放持有的堆上指针，这是通过C++的析构函数实现的。

智能指针的原理

将基本指针类型封装为类对象指针，并在其析构函数里编写delete语句删除指针指向的内存空间。
智能指针都是栈上的对象，所以当函数（或程序）结束时，会自动释放。
应用场景举例：抛出异常后续语句不执行，之前申请空间无法释放，造成内存泄漏

C++11中的三个智能指针

unique_ptr

同一时刻只能由唯一的unique_ptr指向指定对象，不支持复制和赋值；

shared_ptr

可以多个指针指向相同的对象，通过引用计数机制，支持复制和赋值。每引用一次，内部计数+1；析构一次；内部计数-1；计数为0时，释放该指针；

weak_ptr

弱引用，为解决引用计数的互相引用形成环，这样两个指针指向的内存都无法释放的问题。只引用，不计数，使用前需要检查其是否为空。

引用计数的意义

当一个智能指针对象拷贝赋值给另外一个智能指针时，比如shared_ptr<int> b = a;a和b两个智能指针指向了同一块堆上的空间，a或b中的任意一个对象出作用域时，都不应该释放堆上的空间，因为还有另外一个智能指针对象在引用这个堆空间，于是就引入了引用计数机制来解决这个问题。当一个智能指针对象被创建时，会在堆上创建一个用于计数的空间，当shared_ptr<int> b = a；执行后，b对象浅拷贝a对象的计数区指针，然后将计数区的值+1。这样就相当于拷贝赋值出的一组智能指针都指向同一块堆上的数据空间，同时还共享另外一块堆上计数区（这也是叫做shared_ptr的原因）。在智能指针对象析构时，不是简单的直接释放持有的堆数据空间，而是先将共享的引用计数-1，之后发现引用计数为0的话，才调用delete。

实现一个简单的智能指针

/*实现一个简单的智能指针（shared_ptr模板）*/
#include <iostream>

template <typename T>
class SmartPointer
{
private:
    T * _ptr;
    size_t * Count;

    void destory()      //计数为0时，释放该指针
    {
        if(*Count==0)
        {
            delete _ptr;
            delete Count;
        }
    }

    void releaseCount()
    {
        if(_ptr)
        {
            (*Count)--;
            destory();
        }
    }

public:
    SmartPointer(T * p=0):_ptr(p),Count(new size_t) //构造函数
    {
        if(p)
            *Count = 1;
        else
            *Count = 0;
    }

    SmartPointer(const SmartPointer<T> & obj) //复制构造函数
    {
        if(this != &obj)
        {
            _ptr=obj._ptr;
            Count=obj.Count;
            ++(*Count);
        }
    }

    SmartPointer & operator = (const SmartPointer & obj)//重载赋值运算符
    {
        if(_ptr=obj._ptr) return *this; //相等，直接返回自己
        releaseCount();//不等，先清空本智能指针内内容；
        _ptr=obj._ptr;
        Count=obj.Count;
        ++(*Count); //计数加1

        return *this;
    }

    T& operator *() //重载解指针运算符
    {
        if(_ptr) return *_ptr;
    }

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

    size_t count()
    {
        return *Count;
    }

    ~SmartPointer()
    {
        destory();
    }

};


using namespace std;

int main()
{
    SmartPointer<char> cp1(new char ('a'));
    cout<<cp1.count()<<endl;

    SmartPointer<char> cp2(cp1);
    cout << cp1.count() << endl;
    cout << cp2.count() << endl;

    SmartPointer<char> cp3;
    cp3 = cp2;
    cout << cp1.count() << endl;
    cout << cp2.count() << endl;
    cout << cp3.count() << endl;

    return 0;
}

image.png

处理循环引用问题

两个对象互相使用一个shared_ptr成员变量指向对方的会造成循环引用。
更直白的解释：即A内部有指向B，B内部有指向A，这样对于A，B必定是在A析构后B才析构，对于B，A必定是在B析构后才析构A，这就是循环引用问题，违反常规，导致内存泄露。

class B;
class A
{
public:
　　shared_ptr<B> m_b;
};
 
class B
{
public:
　　shared_ptr<A> m_a;
};
 
int main()
{
　　while (true)
　　{
　　　　shared_ptr<A> a(new A); //new出来的A的引用计数此时为1
　　　　shared_ptr<B> b(new B); //new出来的B的引用计数此时为1
　　　　a->m_b = b; //B的引用计数增加为2
　　　　b->m_a = a; //A的引用计数增加为2
　　}
}

b先出作用域，B的引用计数减少为1，不为0，所以堆上的B空间没有被释放，且B持有的A也没有机会被析构，A的引用计数也完全没减少
a后出作用域，同理A的引用计数减少为1，不为0，所以堆上A的空间也没有被释放
解决方法
在不得不使用循环引用的时候，让引用链上的一方持用普通指针（或弱智能指针weak_ptr）即可。