C++ 智能指针内存泄漏问题

shared_ptr相互嵌套导致循环引用

代码示例

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

class B;

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed\n"; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() { std::cout << "B destroyed\n"; }
};

int main() {
    // 创建 shared_ptr 对象
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();

    // 相互引用
    a->b_ptr = b;
    b->a_ptr = a;

    cout<<"use_count of a:"<<a.use_count()<<endl;
    cout<<"use_count of b:"<<b.use_count()<<endl;
    return 0;
}

解释说明

  1. 创建了两个 std::shared_ptr 对象 a 和 b。
  2. a 持有 b 的 shared_ptr，b 持有 a 的 shared_ptr。
  3. 当 main 函数结束时，a 和 b 的引用计数不会减少到零，因此它们的析构函数不会被调用。
  4. 导致内存泄漏，因为对象 A 和 B 的内存不会被释放。

 解决方法

为了避免这种循环引用的问题，可以使用 std::weak_ptr。std::weak_ptr 是一种弱智能指针，它不会增加对象的引用计数。它可以用来打破循环引用，从而防止内存泄漏。

#include <iostream>
#include <memory>
using namespace std;
class B;  // 先声明类 B，使得 A 和 B 可以互相引用。

class A {
public:
    std::shared_ptr<B> b_ptr; // A 拥有 B 的强引用
    ~A() { std::cout << "A destroyed\n"; }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // B 拥有 A 的弱引用
    ~B() { std::cout << "B destroyed\n"; }

    void safeAccess() {
        // 尝试锁定 a_ptr 获取 shared_ptr
        if (auto a_shared = a_ptr.lock()) {
            // 安全访问 a_shared 对象
            std::cout << "Accessing A from B\n";
        } else {
            std::cout << "A is already destroyed, cannot access A from B\n";
        }
    }
};

int main() {
    // 创建 shared_ptr 对象
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();

    // 互相引用
    a->b_ptr = b;
    b->a_ptr = a;

    // 安全访问
    b->safeAccess();
    cout<<"use_count of a:"<<a.use_count()<<endl;
    cout<<"use_count of b:"<<b.use_count()<<endl;

    return 0; // 在这里，a 和 b 的引用计数将会正确地减少到零，并且它们将会被销毁。
}

shared_ptr的层次使用没有导致循环引用

shared_ptr<vector<shared_ptr<pair<string, shared_ptr<string>>>>> jsFiles;

这个声明表示 jsFiles 是一个 std::shared_ptr，它指向一个 std::vector，向量中的每个元素是一个 std::shared_ptr，指向一个 std::pair 对象，而这个 std::pair 对象中包含一个 std::string 和一个 std::shared_ptr<std::string>。它们之间只是层次结构，没有跨层次的相互引用 。也就是说没有内存泄漏的问题。证明如下：

#include <iostream>
#include <vector>
#include <memory>
#include <string>

using namespace std;
// 自定义 String 类，模拟 std::string
class MyString {
public:
    std::string data;
    MyString(const std::string& str) : data(str) {
        std::cout << "MyString created: " << data << std::endl;
    }
    ~MyString() {
        std::cout << "MyString destroyed: " << data << std::endl;
    }
    // 添加输出操作符重载
    friend std::ostream& operator<<(std::ostream& os, const MyString& myStr) {
        os << myStr.data;
        return os;
    }
};

// 自定义 Pair 类，模拟 std::pair
template<typename K, typename V>
class MyPair {
public:
    K first;
    V second;
    MyPair(const K& key, const V& value) : first(key), second(value) {
        std::cout << "MyPair created: {" << first << ", " << *second << "}" << std::endl;
    }
    ~MyPair() {
        std::cout << "MyPair destroyed: {" << first << ", " << *second << "}" << std::endl;
    }
};

int main() {
    // 创建 jsFiles，它是一个 shared_ptr，指向 vector
    auto jsFiles = std::make_shared<std::vector<std::shared_ptr<MyPair<std::string, std::shared_ptr<MyString>>>>>();

    // 添加元素
    auto innerPair1 = std::make_shared<MyPair<std::string, std::shared_ptr<MyString>>>("file1", std::make_shared<MyString>("content of file1"));
    auto innerPair2 = std::make_shared<MyPair<std::string, std::shared_ptr<MyString>>>("file2", std::make_shared<MyString>("content of file2"));
    
    jsFiles->push_back(innerPair1);
    jsFiles->push_back(innerPair2);

    // 访问元素
    for (const auto& pairPtr : *jsFiles) {
        std::cout << "Filename: " << pairPtr->first << ", Content: " << *pairPtr->second << std::endl;
    }

    // 离开作用域时，智能指针会自动销毁它们管理的对象
    return 0;
}

同时也证明了一个结论，构造函数和析构函数的调用顺序是相反的。 

回调函数中的循环引用问题

值捕获

#include <iostream>
#include <memory>
#include <functional>

class MyClass {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }

    void setCallback(std::function<void()> cb) {
        callback_ = cb;
    }

    void executeCallback() {
        if (callback_) {
            callback_();
        }
    }

private:
    std::function<void()> callback_;
};

void createNoLeak() {
    auto myObject = std::make_shared<MyClass>();

    myObject->setCallback([=]() {
        std::cout << "Callback executed, myObject use count: " << myObject.use_count() << std::endl;
    });

    myObject->executeCallback();
    
}

int main() {
    createNoLeak();
    std::cout << "End of program" << std::endl;
    return 0;
}

可以看出myObject最后没有调用析构函数，是shared_ptr循环引用了。

引用捕获

如果换为引用捕获，则不会造成 shared_ptr循环引用。虽然这种方式不会增加引用计数，但需要特别注意捕获对象的生命周期，防止在 lambda 被调用时，对象已经被销毁，从而导致未定义行为。

如何解决 

#include <iostream>
#include <memory>
#include <functional>

class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }

    void setCallback(std::function<void()> cb) {
        callback_ = cb;
    }

    void executeCallback() {
        if (callback_) {
            callback_();
        }
    }

private:
    std::function<void()> callback_;
};

void createNoLeak() {
    auto myObject = std::make_shared<MyClass>();

    std::weak_ptr<MyClass> weakPtr = myObject;

    myObject->setCallback([weakPtr]() {
        if (auto sharedPtr = weakPtr.lock()) {
            std::cout << "Callback executed, object is valid" << std::endl;
        } else {
            std::cout << "Object already destroyed" << std::endl;
        }
    });

    myObject->executeCallback();
    // 这里 myObject 是按 weak_ptr 捕获，当 createNoLeak() 结束时，myObject 的生命周期也就结束了，并且引用计数=0
}

int main() {
    createNoLeak();
    std::cout << "End of program" << std::endl;
    return 0;
}

  • weakPtr.lock() 的使用：持有 std::weak_ptr，并且需要检查或者使用其管理的对象。如果对象仍然存在（即它的 shared_ptr 引用计数大于零），我们希望获取一个 shared_ptr 来安全地使用该对象。否则，weak_ptr.lock() 返回一个空的 shared_ptr。
  • std::enable_shared_from_this 是一个非常有用的标准库模板类，用于解决一个特定的问题: 当一个类的成员函数需要创建一个指向自己(this)的 std::shared_ptr 时，这类问题如何安全地实现。

std::enable_shared_from_this

背景问题

在使用 std::shared_ptr 管理对象时，有时会遇到需要在类的成员函数中获取该对象的 shared_ptr 的情况。例如，在一个类的成员函数中，如果想要得到一个指向该对象的 shared_ptr，不能简单地使用 std::shared_ptr<MyClass>(this)，因为这会创建一个新的 shared_ptr，而不是增加现有的 shared_ptr 的引用计数。这可能导致对象被提前销毁或者多次销毁。

std::enable_shared_from_this 的作用

通过继承 std::enable_shared_from_this，类就能够安全地使用 shared_from_this 方法，从而获取一个 shared_ptr，该 shared_ptr 与其他 shared_ptr 共享所有权，而不会重复增加引用计数。

使用示例

#include <iostream>
#include <memory>

// 定义 MyClass 继承 std::enable_shared_from_this<MyClass>
class MyClass : public std::enable_shared_from_this<MyClass> {
public:
    MyClass() { std::cout << "MyClass created" << std::endl; }
    ~MyClass() { std::cout << "MyClass destroyed" << std::endl; }

    // 一个成员函数，它需要返回一个指向自身的 shared_ptr
    std::shared_ptr<MyClass> getSharedPtr() {
        // 使用 shared_from_this 返回一个 shared_ptr
        return shared_from_this();
    }

    void doSomething() {
        auto ptr = shared_from_this(); // 获取 shared_ptr
        std::cout << "Doing something with MyClass instance, ref count: " << ptr.use_count() << std::endl;
    }
};

void exampleFunction() {
    // 创建 MyClass 对象的 shared_ptr
    auto myObject = std::make_shared<MyClass>();

    // 调用成员函数获取 shared_ptr
    auto mySharedPtr = myObject->getSharedPtr();

    std::cout << "Reference count after getSharedPtr: " << mySharedPtr.use_count() << std::endl;
    
    myObject->doSomething();
}

int main() {
    exampleFunction();
    return 0;
}

注意

1.创建对象:
只有通过 std::shared_ptr 创建或管理的对象，才能安全地使用 shared_from_this。

2. 保护避免使用 new 操作符:
直接使用 new 操作符创建的对象不能正确使用 shared_from_this，这样做可能会导致未定义行为（例如崩溃）。

为什么 std::enable_shared_from_this 是必要的？

std::enable_shared_from_this 内部维护了一个弱引用（std::weak_ptr）指向当前对象。这个弱引用确保不会增加引用计数，同时允许 shared_from_this 方法安全地获取 std::shared_ptr，从而真正共享管理的对象，避免不安全的重复引用计数增加。

通过这样做，C++ STL 提供了一种方便而安全的方式来管理对象的生命周期，特别是在需要从对象内部生成 shared_ptr的情境下。

总结

通过继承 std::enable_shared_from_this，MyClass 能够安全地在其成员函数中创建返回指向自身的 std::shared_ptr，避免不必要的重复引用计数，从而有效地管理和共享对象生命周期。这样既提升了代码的安全性，也使得对象生命周期管理变得更加简洁和直观。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/772543.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【前端项目笔记】8 订单管理

【前端项目笔记】8 订单管理

订单管理 效果展示&#xff1a; 在开发功能之前先创建分支order cls 清屏 git branch 查看所有分支&#xff08;*代表当前分支&#xff09; git checkout -b order 新建分支order git push -u origin order 将本地的当前分支提交到云端仓库origin中命名为order 通过路由方式…
阅读更多...
014-GeoGebra基础篇-快速解决滑动条的角度无法输入问题

014-GeoGebra基础篇-快速解决滑动条的角度无法输入问题

有客户反馈&#xff0c;他的Geogebra一直有个bug&#xff0c;那就是输入角度最大值时总不按照他设定的展示&#xff0c;快被气炸了~ 目录 一、问题复现&#xff08;1&#xff09;插入一个滑动条&#xff08;2&#xff09;选择Angle&#xff08;3&#xff09;输入90&#xff0c;…
阅读更多...
|从零搭建网络| VisionTransformer网络详解及搭建

|从零搭建网络| VisionTransformer网络详解及搭建

&#x1f31c;|从零搭建网络| VisionTransformer系列网络详解及搭建&#x1f31b; 文章目录 &#x1f31c;|从零搭建网络| VisionTransformer系列网络详解及搭建&#x1f31b;&#x1f31c; 前言 &#x1f31b;&#x1f31c; VIT模型详解 &#x1f31b;&#x1f31c; VIT模型架…
阅读更多...
Buuctf之不一样的flag（迷宫题）

Buuctf之不一样的flag（迷宫题）

首先&#xff0c;进行查壳无壳&#xff0c;32bit&#xff0c;丢进ida32中进行反编译进入main函数&#xff0c;对其进行分析&#xff0c;可以在一旁打上注释&#xff0c;这边最关键的一个点就是&#xff0c;需要联想到这是一个迷宫题&#xff0c;很小的迷宫题&#xff0c;迷宫就…
阅读更多...
Kindling-OriginX 在快手 Staging 环境的异常诊断效果分享

Kindling-OriginX 在快手 Staging 环境的异常诊断效果分享

业务可用性问题的快速诊断&#xff0c;历来是行业互联网公司面临的重大挑战&#xff0c;快手也不外如是。Kindling-OriginX的体系化设计理念快速打动了我们的工程师。快手随即开始了内部真实业务的验证落地&#xff1b;落地过程中&#xff0c;Kindling-OriginX能高效覆盖大部分…
阅读更多...
classin视频下载提取为mp4教程

classin视频下载提取为mp4教程

最近在上classin网课&#xff0c;无奈网课视频要过期了&#xff0c;所以想保存下来&#xff01; 下面介绍提取的教程 我们可以绕过最开始的握手&#xff0c;就是先播放了一段时间后&#xff0c;再打开抓包&#xff0c;回到Classin播放后&#xff0c;就可以获得网课链接了 直接打…
阅读更多...
Python的Django部署uwsgi后自签名实现的HTTPS

Python的Django部署uwsgi后自签名实现的HTTPS

通过SSL/TLS来加密和客户端的通信内容。提高网络安全性&#xff0c;但是会损耗部分的服务器资源。 HTTPS 的原理图。 web.key 是打死也不能给其他人的。一定要保存好。里面主要是私钥。是各种认证的根基。本地测试的话生成1024的即可&#xff0c;如果是生产环境推荐使用2048。…
阅读更多...
技术探索：利用Python库wxauto实现Windows微信客户端的全面自动化管理

技术探索：利用Python库wxauto实现Windows微信客户端的全面自动化管理

项目地址&#xff1a;github-wxauto 点击即可访问 项目官网&#xff1a;wxauto 点击即可访问 &#x1f602;什么是wxauto? wxauto 是作者在2020年开发的一个基于 UIAutomation 的开源 Python 微信自动化库&#xff0c;最初只是一个简单的脚本&#xff0c;只能获取消息和发送…
阅读更多...
argparse大坑之parser

argparse大坑之parser

parser.add_argument(--rate,help"--rate 0.5 means that there is a 50% probability;",typefloat,default0.5)此时用-h输出usage会报错如下&#xff1a; 最后发现是因为parser的help里面出现了%&#xff0c;改了之后就好了。真坑啊&#xff01;
阅读更多...
centos7安装mqtt服务端

centos7安装mqtt服务端

下载emqx centos7安装包 https://download.csdn.net/download/qq32933432/89515118 安装 cd /opt/ mkdir emqx # 把文件上传进去 rpm -ivh emqx-centos7-4.2.7-x86_64.rpm # 运行 emqx start确保防火墙将1883和18083这两端口开启&#xff0c;可视化界面&#xff1a;http://主…
阅读更多...
腾讯云函数部署环境[使用函数URL]

腾讯云函数部署环境[使用函数URL]

使用函数URL 之前使用的是网关API,最近腾讯云的网关API说要关闭了,所以没有办法这里改成函数URL,使用后发现只要不是在浏览器直接访问的情况,函数URL都可以满足! 这里结合腾讯云函数node.js返回自动带反斜杠这篇文章来做说明,比如这里的URL如下: 结合文章腾讯云函数node.js返…
阅读更多...
科东软件精彩亮相华南工博会，展现未来工业前沿技术

科东软件精彩亮相华南工博会，展现未来工业前沿技术

近日&#xff0c;华南国际工业博览会在深圳成功举办。科东软件携众多前沿技术、解决方案及最新应用案例精彩亮相&#xff0c;为参展观众带来了一场工业智能的科技盛宴。 鸿道操作系统&#xff08;Intewell&#xff09; 科东软件重点展示了鸿道操作系统&#xff08;Intewell&…
阅读更多...
幻兽帕鲁卡顿严重、延迟高怎么办？幻兽帕鲁卡顿问题处理

幻兽帕鲁卡顿严重、延迟高怎么办？幻兽帕鲁卡顿问题处理

幻兽帕鲁更是一款支持多人游戏模式的生存制作游戏。玩家们可以邀请好友一同加入这个充满奇幻与冒险的世界&#xff0c;共同挑战强大的敌人&#xff0c;分享胜利的喜悦。在多人模式中&#xff0c;玩家之间的合作与竞争将成为游戏的一大看点。玩家们需要充分发挥自己的智慧和策略…
阅读更多...
小白 | 华为云docker设置镜像加速器

小白 | 华为云docker设置镜像加速器

一、操作场景 通过docker pull命令下载镜像中心的公有镜像时&#xff0c;往往会因为网络原因而需要很长时间&#xff0c;甚至可能因超时而下载失败。为此&#xff0c;容器镜像服务提供了镜像下载加速功能&#xff0c;帮助您获得更快的下载体验。 二、约束与限制 构建镜像的客…
阅读更多...
软件开发中常用的11款bug记录、跟踪、管理系统对比【2024更新】

软件开发中常用的11款bug记录、跟踪、管理系统对比【2024更新】

软件开发项目的复杂性不断增加&#xff0c;有效的bug管理变得尤为关键。对开发团队而言&#xff0c;没有什么比选择一款合适的Bug跟踪工具更重要的了。工具的功能、界面友好度、整合能力及成本都是决策的关键因素。 1、PingCode 推荐指数&#xff1a;五星 简介&#xff1a;P…
阅读更多...
采用B/S模式 可跨平台使用的数据采集监控平台！

采用B/S模式 可跨平台使用的数据采集监控平台！

数据采集监控平台是一款专注于工业企业生产设备管理、数据采集、数据分析、数据管理、数据存储、数据传输等的软件系统。系统具备丰富的接口&#xff0c;配置灵活&#xff0c;方便部署&#xff0c;通过采集企业生产设备的数据集中处理&#xff0c;将各个信息孤岛有机连接&#…
阅读更多...
【图像分割】mask2former：通用的图像分割模型详解

【图像分割】mask2former：通用的图像分割模型详解

最近看到几个项目都用mask2former做图像分割&#xff0c;虽然是1年前的论文&#xff0c;但是其attention的设计还是很有借鉴意义&#xff0c;同时&#xff0c;mask2former参考了detr的query设计&#xff0c;实现了语义和实例分割任务的统一。 1.背景 1.1 detr简介 detr算是第…
阅读更多...
.NET发布成单个文件后获取不到程序所在路径的问题

.NET发布成单个文件后获取不到程序所在路径的问题

.net程序不发布成单个文件&#xff0c;所以运行都是正常的&#xff0c;但是发布成单个文件后发现使用&#xff1a; var basePath Path.GetDirectoryName((System.Reflection.Assembly.GetExecutingAssembly().Location)); 获取不到应用程序所在的路径了。 找一下几个获取本程…
阅读更多...
Flutter集成高德导航SDK（Android篇）（JAVA语法）

Flutter集成高德导航SDK（Android篇）（JAVA语法）

先上flutter doctor&#xff1a; flutter sdk版本为&#xff1a;3.19.4 引入依赖&#xff1a; 在app的build.gradle下&#xff0c;添加如下依赖&#xff1a; implementation com.amap.api:navi-3dmap:10.0.700_3dmap10.0.700navi-3dmap里面包含了定位功能&#xff0c;地图功能…
阅读更多...
Cloudflare 推出一款免费对抗 AI 机器人的可防止抓取数据工具

Cloudflare 推出一款免费对抗 AI 机器人的可防止抓取数据工具

上市云服务提供商Cloudflare推出了一种新的免费工具&#xff0c;可防止机器人抓取其平台上托管的网站以获取数据以训练AI模型。 一些人工智能供应商&#xff0c;包括谷歌、OpenAI 和苹果&#xff0c;允许网站所有者通过修改他们网站的robots.txt来阻止他们用于数据抓取和模型训…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站