C++动态内存管理之智能指针

• 不要保存p.get()的返回值 ，无论是保存为裸指针还是shared_ptr都是错误的
• 保存为裸指针不知什么时候就会变成空悬指针，保存为shared_ptr则产生了独立指针
• 不要delete p.get()的返回值 ，会导致对一块内存delete两次的错误

指定删除器

如果用shared_ptr管理非new对象或是没有析构函数的类时，应当为其传递合适的删除器。

#include <iostream>
#include <memory>

using namespace std;

void DeleteIntPtr(int *p) {
    cout << "call DeleteIntPtr" << endl;
    delete p;
}

int main()
{
    std::shared_ptr<int> p(new int(1), DeleteIntPtr);
    return 0;
}

std::shared_ptr<int> p(new int(1), [](int *p) {

        cout << "call lambda delete p" << endl;

        delete p;

});

#include <iostream>
#include <memory>

using namespace std;

class A;
class B;
class A {
public:
    std::shared_ptr<B> bptr;
    ~A() {
        cout << "A is deleted" << endl;
    }
};

class B {
public:
    std::shared_ptr<A> aptr;
    ~B() {
        cout << "B is deleted" << endl;
    }
};

int main()
{
    {
        std::shared_ptr<A> ap(new A);
        std::shared_ptr<B> bp(new B);
        ap->bptr = bp;
        bp->aptr = ap;
    }
    cout<< "main leave" << endl; // 循环引用导致ap bp退出了作用域都没有析构
    return 0;
}

3.2 unique_ptr独占的智能指针

• unique_ptr是一个独占型的智能指针，不能将其赋值给另一个unique_ptr
• unique_ptr可以指向一个数组
• unique_ptr需要确定删除器的类型

3.2.1 unique_ptr使用特点

1、unique_ptr不允许复制，但可以通过函数返回给其他的unique_ptr，还可以通过std::move来转移到其他的unique_ptr，这样它本身就不再拥有原来指针的所有权了。例如

unique_ptr<T> my_ptr(new T); // 正确

unique_ptr<T> my_other_ptr = std::move(my_ptr); // 正确

unique_ptr<T> ptr = my_ptr; // 报错，不能复制 ​​​​​​​

2、unique_ptr可以指向一个数组，而shared_ptr不可以，代码如下所示

std::unique_ptr<int []> ptr(new int[10]);

ptr[9] = 9;

std::shared_ptr<int []> ptr2(new int[10]); // 这个是不合法的

3、unique_ptr指定删除器和shared_ptr有区别

std::shared_ptr<int> ptr3(new int(1), [](int *p){delete p;}); // 正确

std::unique_ptr<int> ptr4(new int(1), [](int *p){delete p;}); // 错误

unique_ptr需要确定删除器的类型，所以不能像shared_ptr那样直接指定删除器，可以这样写：

std::unique_ptr<int, void(*)(int*)> ptr5(new int(1), [](int *p){delete p;}); //正确

3.3 weak_ptr弱引用的智能指针

        share_ptr虽然已经很好用了，但是有一点share_ptr智能指针还是有内存泄露的情况，当两个对象相互使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效，从而导致内存泄漏。

        weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象. 进行该对象的内存管理的是那个强引用的shared_ptr， weak_ptr只是提供了对管理对象的一个访问手段。

        weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作, 它只可以从一个 shared_ptr 或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。

3.3.1 weak_ptr的基本用法

1. 通过use_count()方法获取当前观察资源的引用计数，如下所示：

shared_ptr<int> sp(new int(10));

weak_ptr<int> wp(sp);

cout << wp.use_count() << endl; //结果讲输出1

2. 通过expired()方法判断所观察资源是否已经释放，如下所示：

shared_ptr<int> sp(new int(10));

weak_ptr<int> wp(sp);

if(wp.expired())

        cout << "weak_ptr无效,资源已释放";

else

        cout << "weak_ptr有效";

3. 通过lock方法获取监视的shared_ptr，如下所示：

std::weak_ptr<int> gw;

void f()

{

        auto spt = gw.lock();

        if(gw.expired()) {

                cout << "gw无效,资源已释放";

        }

        else {

                cout << "gw有效, *spt = " << *spt << endl;

        }

}

int main()

{

        {

                auto sp = std::make_shared<int>(42);

                gw = sp;

                f();

        }

        f();

        return 0;

}

#include <iostream>
#include <memory>
using namespace std;

class A: public std::enable_shared_from_this<A>
{
public:
    shared_ptr<A>GetSelf()
    {
        return shared_from_this(); //
    }
    ~A()
    {
        cout << "Destructor A" << endl;
    }
};

int main()
{
    shared_ptr<A> sp1(new A);
    shared_ptr<A> sp2 = sp1->GetSelf(); // ok
    return 0;
}

#include <iostream>
#include <memory>

using namespace std;

class A;
class B;
class A {
public:
    std::shared_ptr<B> bptr;
    ~A() {
        cout << "A is deleted" << endl;
    }
};

class B {
public:
    std::shared_ptr<A> aptr;
    ~B() {
        cout << "B is deleted" << endl;
    }
};

int main()
{
    {
        std::shared_ptr<A> ap(new A);
        std::shared_ptr<B> bp(new B);
        ap->bptr = bp;
        bp->aptr = ap;
    }
    cout<< "main leave" << endl; // 循环引用导致ap bp退出了作用域都没有析构
    return 0;
}

情况1：多线程代码操作的是同一个shared_ptr的对象，此时是不安全的。

比如std::thread的回调函数，是一个lambda表达式，其中引用捕获了一个shared_ptr

std::thread td([&sp1]()){....});

又或者通过回调函数的参数传入的shared_ptr对象，参数类型引用

void fn(shared_ptr<A>&sp) {

...

}

..

std::thread td(fn, sp1);

这时候必然不是线程安全的。

情况2：多线程代码操作的不是同一个shared_ptr的对象

这里指的是管理的数据是同一份，而shared_ptr不是同一个对象。比如多线程回调的lambda的是按值捕获的对象。

std::thread td([sp1]()){....});

另一个线程传递的shared_ptr是值传递，而非引用：

void fn(shared_ptr<A>sp) {

...

}

..

std::thread td(fn, sp1);

这时候每个线程内看到的sp，他们所管理的是同一份数据，用的是同一个引用计数。但是各自是不同的对象，当发生多线程中修改sp指向的操作的时候，是不会出现非预期的异常行为的。也就是说，如下操作是安全的。

void fn(shared_ptr<A>sp) {

        ...

        if(..){

                sp = other_sp;

        } else {

                sp = other_sp2;

        }

}

需要注意：所管理数据的线程安全性问题。显而易见，所管理的对象必然不是线程安全的，必然 sp1、sp2、sp3智能指针实际都是指向对象A， 三个线程同时操作对象A，那对象的数据安全必然是需要对象A自己去保证。