cpp - shared_ptr详解

编程 评论

转自守望的个人博客

shared_ptr

  • 在 cpp - unique_ptr详解 说到，如果有可能就使用unique_ptr，然后很多时候对象是需要共享的，因此shared_ptr也就会用得很多。shared_ptr允许多个指针指向同一个对象，当指向对象的最后一个shared_ptr销毁时，该对象也就会自动销毁。

基本使用

  • 它的很多操作与unique_ptr类似。例如：

    1
    2
    3
    4
    5
    6
    shared_ptr<int> sp; //声明一个指向int类型的智能指针
    sp.reset(new int(42));

    auto sp1 = make_shared<string>("hello"); //sp1是一个智能指针

    shared_ptr sp2(new int(42);

  • 而 make_shared 方式是推荐的一种，它使用一次分配，比较安全。

哪些操作会改变计数

  • 我们都知道，当引用计数为0时，shared_ptr所管理的对象自动销毁，那么那些情况会影响引用计数呢？

赋值

  • 例如：

    1
    auto sp = make_shared<int>(1024);//sp的引用计数为1

  • 再比如：

    1
    2
    3
    auto sp1 = make_shared<string>("obj1");
    auto sp2 = make_shared<string>("obj2");
    auto sp1 = sp2;

  • 该操作会减少sp1的引用计数，增加sp2的引用计数。有的人可能不理解，为什么这样还会减少sp1的引用计数？

  • 试想一下，sp1指向对象obj1，sp2指向对象obj2，那么赋值之后，sp1也会指向obj2，那就是说指向obj1的就少了，指向obj2的就会多，如果此时没有其他shared_ptr指向obj1，那么obj1将会销毁。

拷贝

  • 例如：

    1
    2
    auto sp2 = make_shared<int>(1024);
    auto sp1(sp2);

  • 该操作会使得sp1和sp2都指向同一个对象。

  • 而关于拷贝比较容易忽略的就是作为参数传入函数：

    1
    2
    auto sp2 = make_shared<int>(1024);
    func(sp2); //func的执行会增加其引用计数

  • 可以看一个具体的例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    #include<iostream>
    #include<memory>
    void func0(std::shared_ptr<int> sp)
    {
        std::cout<<"fun0:"<<sp.use_count()<<std::endl;
    }
    void func1(std::shared_ptr<int> &sp)
    {
        std::cout<<"fun1:"<<sp.use_count()<<std::endl;
    }
    int main()
    {
        auto sp = std::make_shared<int>(1024);
        func0(sp);
        func1(sp);
        return 0;
    }

  • 其运行输出结果为：

    1
    2
    fun0:2                                                    
    fun1:1

  • 很显然，fun0，拷贝了shard_ptr sp，而fun1，并没有拷贝，因此前者会增加引用计数，而后者并不影响。

reset

  • 调用reset会减少计数：

    1
    sp.reset()

  • 而如果sp是唯一指向该对象的，则该对象被销毁。

应当注意使用的方式

  • 虽然shared_ptr能很大程度避免内存泄漏，但是使用不当，仍然可能导致意外发生。

存放于容器中的shared_ptr

  • 如果你的容器中存放的时shared_ptr，而你后面又不再需要它时，记得使用erase删除那些不要的元素，否则由于引用计数一直存在，其对象将始终得不到销毁，除非容器本身销毁。

不要使用多个裸指针初始化多个shared_ptr

  • 注意，下面方式是不该使用的：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #include<iostream>
    #include<memory>
    int main()
    {
        auto *p = new std::string("hello");
        std::shared_ptr<std::string> sp1(p);
        /*不要这样做！！*/
        std::shared_ptr<std::string> sp2(p);
        return 0;
    }

  • 这样会导致两个shared_ptr管理同一个对象，当其中一个被销毁时，其管理的对象会被销毁，而另外一个销毁时，对象会二次销毁，然而实际上，对象已经不在了，最终造成严重后果。

  • 而与这种情况类似的，就是使用get()获取裸指针，然后去初始化另外一个shared_ptr，或者delete get返回的指针：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #include<iostream>
    #include<memory>
    int main()
    {
        auto sp = std::make_shared<std::string>("wechat:shouwangxiansheng");
        std::string *p = sp.get();
        std::shared_ptr<std::string> sp2(p);/*不要这样做!!*/
        delete p;/*不要这样做*/
        return 0;
    }

如果对象不是new分配的，请传递删除器

  • 与unique_ptr类似，它可以指定删除器，默认是使用delete。例如：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    #include<iostream>
    #include<unistd.h>
    #include<memory>
    void myClose(int *fd)
    {
        close(*fd);
    }
    int main()
    {
        int socketFd = 10;//just for example
        std::shared_ptr<int> up(&socketFd,myClose);
        return 0;
    }

与unique_ptr的区别

  • 首先最明显的区别自然是它们一个是专享对象，一个是共享对象。而正是由于共享，包括要维护引用计数等，它带来的开销相比于unique_ptr来说要大。

  • 另外，shared_ptr无法直接处理数组，因为它使用delete来销毁对象，而对于数组，需要用delete[]。因此，需要指定删除器：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    #include<iostream>
    #include<memory>
    int main()
    {
        auto sp = std::make_shared<std::string>("wechat:shouwangxiansheng");
        std::string *p = sp.get();
        //std::shared_ptr<int> sp1(new int[10]);//不能这样
        std::shared_ptr<int> sp1(new int[10],[](int *p){delete[] p;});
        return 0;
    }

  • 示例中使用了lambda表达式。

  • 不过一般来说，好好的容器不用，为什么要用动态数组呢？

总结

  • 以上就是shared_ptr基本内容，一般来说，规范使用shared_ptr能很大程度避免内存泄露。注意，shared_ptr提供，*，->操作，不直接提供指针运算和[]。

enable_shared_from_this

  • std::enable_shared_from_this 能让一个对象（假设其名为 t ，且已被一个 std::shared_ptr 对象 pt 管理）安全地生成其他额外的 std::shared_ptr 实例（假设名为 pt1, pt2, … ） ，它们与 pt 共享对象 t 的所有权。

  • 若一个类 T 继承 std::enable_shared_from_this ，则会为该类 T 提供成员函数： shared_from_this 。 当 T 类型对象 t 被一个为名为 pt 的 std::shared_ptr 类对象管理时，调用 T::shared_from_this 成员函数，将会返回一个新的 std::shared_ptr 对象，它与 pt 共享 t 的所有权。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <iostream>
#include <memory>

class Test : public std::enable_shared_from_this<Test>
{
public:
    Test(int a)
        : a(a)
        , b("sdf")
    {
    }

    void show()
    {
        std::cout << a << b << std::endl;
    }

    int a;
    char* b;
};

int main()
{
    auto t = std::make_shared<Test>(1);
    auto t2 = t->shared_from_this();
    t->show();
    t2->show();

    t->a = 23;

    t->show();
    t2->show();
}
  • 当 t 的值发生变化的时候，t2 的值也会变化

QinHanGame Developer & Designer

当你发现自己的才华撑不起野心时，就请安静下来学习吧！