（P48-P50）使用weak_ptr解决shared_ptr管理的内存被重复析构的问题，解决shared_ptr内存泄漏的问题

已于 2022-06-15 23:22:45 修改
阅读量542 收藏
点赞数 2
分类专栏： C++ and mysql 文章标签： c++
于 2022-06-14 23:18:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011436427/article/details/125287475
版权

文章目录

1.简介

在 C++ 中没有垃圾回收机制，必须自己释放分配的内存，否则就会造成内存泄露。解决这个问题最有效的方法是使用智能指针（smart pointer）。

  • 智能指针是存储指向动态分配（堆）对象指针的类，用于生存期的控制，能够确保在离开指针所在作用域时，自动地销毁动态分配的对象，防止内存泄露。智能指针的核心实现技术是引用计数，每使用它一次，内部引用计数加 1，每析构一次内部的引用计数减 1，减为 0 时，删除所指向的堆内存。

C++11 中提供了三种智能指针，使用这些智能指针时需要引用头文件 ：

std::shared_ptr：共享的智能指针
std::unique_ptr：独占的智能指针
std::weak_ptr：弱引用的智能指针，它不共享指针，不能操作资源，是用来监视 shared_ptr 的。

2.基本使用方法

弱引用智能指针 std::weak_ptr 可以看做是 shared_ptr 的助手，它不管理 shared_ptr 内部的指针。

  • std::weak_ptr 没有重载操作符 * 和 ->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视 shared_ptr 中管理的资源是否存在。

初始化

// 默认构造函数
constexpr weak_ptr() noexcept;
// 拷贝构造
weak_ptr (const weak_ptr& x) noexcept;
template <class U> weak_ptr (const weak_ptr<U>& x) noexcept;
// 通过shared_ptr对象构造
template <class U> weak_ptr (const shared_ptr<U>& x) noexcept;
  • eg：在 C++11 中，weak_ptr 的初始化可以通过以上提供的构造函数来完成初始化
#include <iostream>
#include <memory>
using namespace std;

int main() 
{
    shared_ptr<int> sp(new int);
	
	//weak_ptr<int> wp1; 构造了一个空 weak_ptr 对象
    weak_ptr<int> wp1;
	//weak_ptr<int> wp2(wp1); 通过一个空 weak_ptr 对象构造了另一个空 weak_ptr 对象
    weak_ptr<int> wp2(wp1);
    //weak_ptr<int> wp3(sp); 通过一个 shared_ptr 对象构造了一个可用的 weak_ptr 实例对象
    weak_ptr<int> wp3(sp);

    weak_ptr<int> wp4;
//wp4 = sp; 通过一个 shared_ptr 对象构造了一个可用的 weak_ptr 实例对象（这是一个隐式类型转换）
    wp4 = sp;
    weak_ptr<int> wp5;
//wp5 = wp3; 通过一个 weak_ptr 对象构造了一个可用的 weak_ptr 实例对象
    wp5 = wp3;
    
    return 0;
}

3.其他常用方法

use_count()

  • 通过调用 std::weak_ptr 类提供的 use_count() 方法可以获得当前所观测资源的引用计数，函数原型如下：
// 函数返回所监测的资源的引用计数
long int use_count() const noexcept;
  • eg：修改一下上面的测试程序，添加打印资源引用计数的代码：
    通过打印的结果可以知道，虽然弱引用智能指针 wp3、wp4、wp5 监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了 weak_ptr只是监测资源，并不管理资源。
#include <iostream>
#include <memory>
using namespace std;

int main() 
{
    shared_ptr<int> sp(new int);

    weak_ptr<int> wp1;
    weak_ptr<int> wp2(wp1);
    weak_ptr<int> wp3(sp);
    weak_ptr<int> wp4;
    wp4 = sp;
    weak_ptr<int> wp5;
    wp5 = wp3;

    cout << "use_count: " << endl;
    cout << "wp1: " << wp1.use_count() << endl;
    cout << "wp2: " << wp2.use_count() << endl;
    cout << "wp3: " << wp3.use_count() << endl;
    cout << "wp4: " << wp4.use_count() << endl;
    cout << "wp5: " << wp5.use_count() << endl;
    return 0;
}
  • 测试：
    在这里插入图片描述

expired()

  • 通过调用 std::weak_ptr 类提供的 expired() 方法来判断观测的资源是否已经被释放，函数原型如下：
// 返回true表示资源已经被释放, 返回false表示资源没有被释放
bool expired() const noexcept;
  • eg：weak_ptr 监测的就是 shared_ptr 管理的资源，当共享智能指针调用 shared.reset(); 之后管理的资源被释放，因此 weak.expired() 函数的结果返回 true，表示监测的资源已经不存在了。
#include <iostream>
#include <memory>
using namespace std;

int main() 
{
    shared_ptr<int> shared(new int(10));
    weak_ptr<int> weak(shared);
    cout << "1. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;

    shared.reset();
    cout << "2. weak " << (weak.expired() ? "is" : "is not") << " expired" << endl;

    return 0;
}
  • 测试：
    在这里插入图片描述

lock()

  • 通过调用 std::weak_ptr 类提供的 lock() 方法来获取管理所监测资源的 shared_ptr 对象，函数原型如下：
shared_ptr<element_type> lock() const noexcept;
  • eg：
#include <iostream>
#include <memory>
using namespace std;

int main()
{
    shared_ptr<int> sp1, sp2;
    weak_ptr<int> wp;

    sp1 = std::make_shared<int>(520);
    wp = sp1;
    /*
sp2 = wp.lock(); 通过调用 lock() 方法得到一个用于管理 weak_ptr 对象所监测的资源的共享智能指针对象，
使用这个对象初始化 sp2，此时所监测资源的引用计数为 2
	*/
    sp2 = wp.lock();
    cout << "use_count: " << wp.use_count() << endl;
//sp1.reset(); 共享智能指针 sp1 被重置，weak_ptr 对象所监测的资源的引用计数减 1
    sp1.reset();
    cout << "use_count: " << wp.use_count() << endl;
//sp1 = wp.lock();sp1 重新被初始化，并且管理的还是 weak_ptr 对象所监测的资源，因此引用计数加 1
    sp1 = wp.lock();
    cout << "use_count: " << wp.use_count() << endl;

//共享智能指针对象 sp1 和 sp2 管理的是同一块内存，因此最终打印的内存中的结果是相同的，都是 520
    cout << "*sp1: " << *sp1 << endl;
    cout << "*sp2: " << *sp2 << endl;

    return 0;
}
  • 测试：
    在这里插入图片描述

reset()

  • 通过调用 std::weak_ptr 类提供的 reset() 方法来清空对象，使其不监测任何资源，函数原型如下：
void reset() noexcept;
  • eg:weak_ptr 对象 sp 被重置之后 wp.reset(); 变成了空对象，不再监测任何资源，因此 wp.expired() 返回 true
#include <iostream>
#include <memory>
using namespace std;

int main() 
{
    shared_ptr<int> sp(new int(10));
    weak_ptr<int> wp(sp);
    cout << "1. wp " << (wp.expired() ? "is" : "is not") << " expired" << endl;

    wp.reset();
    cout << "2. wp " << (wp.expired() ? "is" : "is not") << " expired" << endl;

    return 0;
}
  • 测试：
    在这里插入图片描述

4.返回管理 this 的 shared_ptr

如果在一个类中编写了一个函数，通过这个得到管理当前对象的共享智能指针，我们可能会写出如下代码：

  • eg：
#include <iostream>
#include <memory>
using namespace std;

struct Test
{
    shared_ptr<Test> getSharedPtr()
    {
        return shared_ptr<Test>(this);
    }
    
    ~Test()
    {
        cout << "class Test is disstruct ..." << endl;
    }

};

int main() 
{
    shared_ptr<Test> sp1(new Test);
    cout << "use_count: " << sp1.use_count() << endl;
    shared_ptr<Test> sp2 = sp1->getSharedPtr();
    cout << "use_count: " << sp1.use_count() << endl;
    return 0;
}

  • 测试：因为这样会导致析构两次，C++程序不能析构两次
    在这里插入图片描述

  • 解释：通过输出的结果可以看到一个对象被析构了两次，其原因是这样的：在这个例子中使用同一个指针 this 构造了两个智能指针对象 sp1 和 sp2，这二者之间是没有任何关系的，因为 sp2 并不是通过 sp1 初始化得到的实例对象。在离开作用域之后 this 将被构造的两个智能指针各自析构，导致重复析构的错误。

这个问题可以通过 weak_ptr 来解决，通过 wek_ptr 返回管理 this 资源的共享智能指针对象 shared_ptr。

  • C++11 中为我们提供了一个模板类叫做 std::enable_shared_from_this，这个类中有一个方法叫做 shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用 weak_ptr 来监测 this 对象，并通过调用 weak_ptr 的 lock() 方法返回一个 shared_ptr 对象。

  • 修改之后的代码为：

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

struct Test : public enable_shared_from_this<Test>
{
    shared_ptr<Test> getSharedPtr()
    {
        return shared_from_this();
    }
    ~Test()
    {
        cout << "class Test is disstruct ..." << endl;
    }
};

int main()
{
    shared_ptr<Test> sp1(new Test);
    cout << "use_count: " << sp1.use_count() << endl;
    shared_ptr<Test> sp2 = sp1->getSharedPtr();
    cout << "use_count: " << sp1.use_count() << endl;
    return 0;
}
  • 测试：最后需要强调一个细节：在调用 enable_shared_from_this 类的 shared_from_this () 方法之前，必须要先初始化函数内部 weak_ptr 对象，否则该函数无法返回一个有效的 shared_ptr 对象
    在这里插入图片描述

所以shared_pt使用的注意事项如下：

不能使用一个原始地址初始化多个共享智能指针
函数不能返回管理了this的共享智能指针对象
共享智能指针不能循环引用

5.解决循环引用问题

智能指针如果循环引用会导致内存泄露，

  • 比如下面的例子：在测试程序中，共享智能指针 ap、bp 对 TA、TB 实例对象的引用计数变为 2，在共享智能指针离开作用域之后引用计数只能减为1，这种情况下不会去删除智能指针管理的内存，导致类 TA、TB 的实例对象不能被析构，最终造成内存泄露
#include <iostream>
#include <memory>
using namespace std;

struct TA;
struct TB;

struct TA
{
    shared_ptr<TB> bptr;
    ~TA()
    {
        cout << "class TA is disstruct ..." << endl;
    }
};

struct TB
{
    shared_ptr<TA> aptr;
    ~TB()
    {
        cout << "class TB is disstruct ..." << endl;
    }
};

void testPtr()
{
    shared_ptr<TA> ap(new TA);
    shared_ptr<TB> bp(new TB);
    cout << "TA object use_count: " << ap.use_count() << endl;
    cout << "TB object use_count: " << bp.use_count() << endl;

    ap->bptr = bp;
    bp->aptr = ap;
    cout << "TA object use_count: " << ap.use_count() << endl;
    cout << "TB object use_count: " << bp.use_count() << endl;
}

int main()
{
    testPtr();
    return 0;
}
  • 测试：
    在这里插入图片描述

通过使用 weak_ptr 可以解决这个问题，只要将类 TA 或者 TB 的任意一个成员改为 weak_ptr，

  • 修改之后的代码如下：
#include <iostream>
#include <memory>
using namespace std;

struct TA;
struct TB;

struct TA
{
    weak_ptr<TB> bptr;
    ~TA()
    {
        cout << "class TA is disstruct ..." << endl;
    }
};

struct TB
{
    shared_ptr<TA> aptr;
    ~TB()
    {
        cout << "class TB is disstruct ..." << endl;
    }
};

void testPtr()
{
    shared_ptr<TA> ap(new TA);
    shared_ptr<TB> bp(new TB);
    cout << "TA object use_count: " << ap.use_count() << endl;
    cout << "TB object use_count: " << bp.use_count() << endl;

    ap->bptr = bp;
    bp->aptr = ap;
    cout << "TA object use_count: " << ap.use_count() << endl;
    cout << "TB object use_count: " << bp.use_count() << endl;
}

int main()
{
    testPtr();
    return 0;
}
  • 测试：
    在这里插入图片描述

通过输出的结果可以看到类 TA 或者 TB 的对象被成功析构了。

上面程序中，在对类 TA 成员赋值时 ap->bptr = bp; 由于 bptr 是 weak_ptr 类型，这个赋值操作并不会增加引用计数，所以 bp 的引用计数仍然为 1，在离开作用域之后 bp 的引用计数减为 0，类 TB 的实例对象被析构。

在类 TB 的实例对象被析构的时候，内部的 aptr 也被析构，其对 TA 对象的管理解除，内存的引用计数减为 1，当共享智能指针 ap 离开作用域之后，对 TA 对象的管理也解除了，内存的引用计数减为 0，类 TA 的实例对象被析构。

喜欢打篮球的普通人
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ unique_ptr weak_ptr shared_ptr auto_ptr智能指针.doc
07-23
四种智能指针的使用、机制和缺陷分析
C++11智能指针shared_ptr，weak_ptr以及循环引用的问题
sinat_40936062的博客
09-01 546
1.智能指针 通常内存管理中存在以下问题： 重复析构（释放）同一块内存导致程序运行崩溃 例如，如果类中有指针成员，浅拷贝造成两个对象的指针成员指向同一个内存。当程序运行结束，一块内存被析构了两次。 有些资源的内存被释放，但是其指针并未被修改指向。 void test() { int *dp = new int[10]; delete dp[]; //忘记添加dp = nullptr; } 上面这种情况导致后续万一在该函数使用了dp指针，造成程序崩溃。这是因为虽然delete虽然释放了内
[C++11]shared_ptr使用的注意事项(内存被重复析构，内存泄漏问题)
m0_51955470的博客
06-21 3366
adesfg
技巧：多共享动态库中同名对象重复析构问题的解决方法
木牛的博客
06-03 1241
共享库与静态成员 吴 光远 和 孟 先涛 2010 年 10 月 21 日发布 Linux 支持的共享程序库（lib*.so）技术不仅能够有效利用系统资源，而且还对程序设计带来了很大的便利性、通用性等，因此被各种级别的应用系统广泛采用。 动态链接的共享库是在加载应用程序时被加载的，而且它与应用程序是在运行时绑定的：通过动态链接器，将动态共享库映射进应用程序的可执行内存中（动态链接）；在启动应用程序时，动态装载器将所需的共享目标库映射到应用程序的内存（动态装载）。 在通常情况下，共享库都是通过使用附加选
智能指针的用法shared_ptr
方池安夏的博客
02-27 1609
目录智能指针shared_ptr共享的智能指针shared_ptr的基本用法1.初始化reset成员函数make_sharedswap()函数2. 获取原始指针(get())3. 指定删除器使用shared_ptr要注意的问题1.慎用智能指针不要用一个原始指针初始化多个shared_ptr通过shared_from_this()返回this指针。 补充: new\delete和malloc\free https://blog.csdn.net/A_With_better/article/details/12
c++新特性: shared_ptr和unique_ptr
TOPEE362的博客
08-17 1285
shared_ptr和unique_ptr
shared_ptr产生内存泄漏的场景
sinat_31608641的博客
07-07 1155
使用 shared_ptr 可以帮助管理动态分配的内存，它使用引用计数的方式来跟踪共享对象的引用数量，当引用计数为零时，会自动释放内存。
[C++ 11] 使用shared_ptr内存被重复析构错误记录
qq_41520996的博客
04-03 270
原先代码中y为实例，z为指向y的shared_ptr，在程序结束后y先被释放并执行析构函数，而z中的引用计数未受到影响，因此在析构shared_ptr z时仍然会再次执行对y实例的析构操作，导致内存重复析构引发异常。y转换为指针类型后不会被程序自动析构，因此z可以正常对y执行析构操作。运行后报错（错误信息如下图），定位后发现是在main函数体结束后析构过程中出现的问题，输出各析构函数信息后发现原因是y实例被析构了两次，内存重复释放导致报错。(源代码情况类似下图）将源代码中的y改为指针形式。
C++ | 智能指针面试题：使用weak_ptr解决循环引用无法析构的问题
Sauron7i的博客
04-06 1446
经典问题：如何解决智能指针循环引用问题？ （自实现weak_ptr和shared_ptr）
C++拷贝构造器之浅拷贝与内存重析构
Apollon_krj的博客
03-12 1814
一般构造器、析构器、拷贝构造器会被称之为构造函数、析构函数与复制构造函数，但是其与函数还是有一些区别，所以我们以“器”来称呼之。1、构造器、析构器与拷贝构造器：（1）、构造器简析： constructor 构造器 * 与类名相同A()，（A为类名）,无返回值，生成对象时系统自行调用，相当于初始化 * 可以有参数，能够重载、以及设置默认参数 * 如果不自定
c++智能指针（weak_ptr）
程序猿的博客
07-24 1316
weak_ptr是为了配合shared_ptr而引入的一种智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。weak_ptr可以从一个shared_ptr或者另一个weak_ptr对象构造，获得资源的观测权。但weak_ptr没有共享资源，它的构造不会引起指针引用计数的增加。使用weak_ptr的成员函数use_count()可以观测资源的引用计数，另一个成员函数expired()的功能等价于use_c
浅析Boost智能指针:scoped_ptr shared_ptr weak_ptr
09-05
虽然通过弱引用指针可以有效的解除循环引用，但这种方式必须在程序员能预见会出现循环引用的情况下才能使用，也可以是说这个仅仅是一种编译期的解决方案，如果程序在运行过程中出现了循环引用，还是会造成内存泄漏的
C++11新特性之智能指针(shared_ptr/unique_ptr/weak_ptr)
09-01
主要介绍了C++11新特性之智能指针,包括shared_ptr, unique_ptr和weak_ptr的基本使用，感兴趣的小伙伴们可以参考一下
C++11智能指针之weak_ptr详解
08-19
主要介绍了 C++11智能指针之weak_ptr详解，本文通过实例代码给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
C++笔记记录
qq_26105397的博客
08-03 356
c++笔记
对同一类进行两次析构的问题
yc489407826的专栏
09-17 2429
对于同一个类进行两次析构一般情况不会出现任何wenti
3. 类指针与智能指针
轻鸢简掠
09-27 923
3. 对象与类指针、智能指针 本篇主要解答以下问题： 类的对象与类指针的区别 为什么要用智能指针 unique_ptr 和 shared_ptr 普通指针指向的数据不会自动销毁 explicit ：智能指针初始化方式的不同 https://juejin.im/post/6844903993055920141 https://nettee.github.io/posts/2018/Understanding-lvalues-and-rvalues-in-C-and-C/ ...
shared_ptr循环引用问题以及解决方法
菊头蝙蝠的博客
05-28 6335
shared_ptr循环引用问题以及解决方法一、shared_ptr循环引用问题例子一例子二例子三二、weak_ptr解决循环引用问题 一、shared_ptr循环引用问题 什么是循环引用，两个对象相互使用shared_ptr指向对方。造成的后果是：内存泄漏 例子一 下面是循环引用的例子 #include <iostream> #include <memory> using namespace std; class A; class B; class A { public:
c++weak_ptr和shared_ptr的区别
最新发布
11-02
为了解决这个问题，可以使用weak_ptr来打破循环引用，避免内存泄漏。 总之，shared_ptr和weak_ptr都是智能指针，用于管理动态分配的内存。shared_ptr是强引用，会增加内存的引用计数，而weak_ptr是弱引用，不会增加...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喜欢打篮球的普通人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值