C++智能指针

embedded/2024/9/25 15:26:34/

智能指针

  • 1. 异常导致的内存泄露
  • 2. 智能指针的使用及原理
    • 2.1 RAII
  • 3. 库里面的智能指针
    • 3.1 std::auto_ptr
    • 3.2 std::unique_ptr
    • 3.3 std::shared_ptr
      • 3.3.1shared_ptr的缺陷——循环引用
      • 3.3.2 weak_ptr

1. 异常导致的内存泄露

在我们异常那块章节中，我们有提到如果异常发生在malloc/new和free/delete之间的时候，会导致内存泄露。而我们解决办法也是非常的挫的。所以本章节就是用来解决内存泄漏问题的。

在提之前我们来复习一下什么是内存泄漏，以及他带来的危害

  • 什么是内存泄漏 ：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
  • 内存泄漏的危害 ：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏分类
C/C++程序中一般我们关心两种方面的内存泄漏：

  • 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
  5. 总结一下:
    内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

而本章节要将的就是用只能指针来解决内存泄露问题。

2. 智能指针的使用及原理

2.1 RAII

RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
template<class T>
class SmartPtr
{
public:SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){cout << "delete:" << _ptr << endl;delete _ptr;}
private:T* _ptr;
};int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}void Func()
{SmartPtr<int> p1(new int(1));SmartPtr<int> p2(new int(2));cout << div() << endl;
}int main()
{try{Func();}catch(const exception& e){cout << e.what() << endl;}return 0;
}

在这里插入图片描述

  • 上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
T& operator* ()
{return *_ptr;
}
T* operator->()
{return _ptr;
}

虽然上面的只能指针解决了内存泄漏的问题，但是同样也带来了新的问题。就是拷贝构造的时候，如果是深拷贝的话，那么这个智能指针指向的就不是同一块资源，如果是浅拷贝的话，那么同一块内存会被释放两次。就会出现各种各样的错误。同样赋值也是如此。所以这里我们看一下库里面是怎么解决的。

3. 库里面的智能指针

库里面的只能指针在头文件 memory
这里我们就讲常见的三个只能指针。

3.1 std::auto_ptr

开局即暴击，这个智能指针巨坑坑坑坑坑。废话少说我们根据现象来判断。

void Func()
{std::auto_ptr<int> p1(new int(1));std::auto_ptr<int> p2(p1);}int main()
{try{Func();}catch(const exception& e){cout << e.what() << endl;}return 0;
}

我们根据调试现象看一看。
在这里插入图片描述
在这里插入图片描述
发生了什么？用p1拷贝构造个p2后，p1确实是拷贝了，但是p2没了。如果后序会用到p2的解引用就是多空指针进行解引用了。是不是非常的坑，而他的底层实现也是非常的简单粗暴。
这auto_ptr进行了管理权限的转移，被拷贝对象把资源管理权限转移给了拷贝对象，导致背靠背对象悬空。

	template<class T>class auto_ptr{public:auto_ptr(T* ptr):_ptr(ptr){}~auto_ptr(){cout << "delete:" << _ptr << endl;delete _ptr;}auto_ptr(auto_ptr<T>& ap){//管理权转移_ptr = ap._ptr;ap._ptr = nullptr;}auto_ptr<T>& operator=(auto_ptr<T>& ap){// 检测是否为自己给自己赋值if (this != &ap){// 释放当前对象中资源if (_ptr)delete _ptr;// 转移ap中资源到当前对象中_ptr = ap._ptr;ap._ptr = NULL;}return *this;}T& operator* (){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;};
}

3.2 std::unique_ptr

而unique_ptr做的就比较直接简单粗暴，你不是拷贝和赋值都有问题吗，那我直接把你给禁止掉，不让你用不就行了。

template<class T>
class unique_ptr
{
public:unique_ptr(T* ptr):_ptr(ptr){}~unique_ptr(){cout << "delete:" << _ptr << endl;delete _ptr;}unique_ptr(const unique_ptr<T>& ap) = delete;unique_ptr<T>& operator=(const unique_ptr<T>& ap) = delete;T& operator* (){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

3.3 std::shared_ptr

但是有些情况下我们需要用到拷贝构造和赋值呢？所以shared_ptr就解决了这个问题。这里要用到引用计数的概念。

template<class T>
class shared_ptr
{
public:shared_ptr(T* ptr):_ptr(ptr),count(new int(1)){}~shared_ptr(){release();}void release(){//最后一个的时候就释放if (--(*count) == 0){cout << "delete:" << _ptr << endl;delete _ptr;delete count;}}int use_count() const{return *count;}shared_ptr(const shared_ptr<T>& sp){_ptr = sp._ptr;count = sp.count;//++引用计数++(*count);}shared_ptr& operator=(const shared_ptr<T>& sp){//this != &sp 防止自己给自己赋值，因为如果刚开始只有自己，就直接释放了if (_ptr != sp._ptr){release();_ptr = sp._ptr;count = sp.count;;++(*count);}return *this;}T& operator* (){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;int* count;
};

3.3.1shared_ptr的缺陷——循环引用

struct ListNode
{int _data; shared_ptr<ListNode> _prev;shared_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);node1->_next = node2;node2->_prev = node1;return 0;
}

循环引用分析：

  1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
  2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
  3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
  4. 也就是说_next析构了，node2就释放了。
  5. 也就是说_prev析构了，node1就释放了。
  6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

在这里插入图片描述

3.3.2 weak_ptr

这里解决方案就是使用weak_ptr，它的特点就是不遵从RAII，不会是引用计数增加。
在这里插入图片描述

template<class T>
class weak_ptr
{
public:weak_ptr():_ptr(nullptr){}weak_ptr(const shared_ptr<T>& sp){_ptr = sp.get(); // == _ptr = sp._ptr;}weak_ptr& operator=(const shared_ptr<T>& sp){_ptr = sp.get();// == _ptr = sp._ptr;return *this;}T& operator* (){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

struct ListNode
{int _data; qfw::weak_ptr<ListNode> _prev;qfw::weak_ptr<ListNode> _next;~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

在这里插入图片描述


http://www.ppmy.cn/embedded/15464.html

相关文章

【设计模式】9、facade 外观模式

【设计模式】9、facade 外观模式

文章目录 九、外观模式9.1 player9.1.1 player_test.go9.1.2 player.go 9.2 login_register9.2.1 account_test.go9.2.2 account.go 九、外观模式 https://refactoringguru.cn/design-patterns/facade 如果有一个复杂的系统, 内部有很多子系统, 可以用 facade 封装一层, 只暴…
阅读更多...
【汇编语言】流程转移和子程序

【汇编语言】流程转移和子程序

【汇编语言】流程转移和子程序 文章目录 【汇编语言】流程转移和子程序前言一、“转移”综述二、操作符offset三、jmp指令jmp指令——无条件转移jmp指令&#xff1a;依据位移进行转移两种段内转移远转移&#xff1a;jmp far ptr 标号转移地址在寄存器中的jmp指令转移地址在内存…
阅读更多...
csdn上最详细的黑客技术入门教程，从零基础到精通 看这一篇就够了

csdn上最详细的黑客技术入门教程，从零基础到精通 看这一篇就够了

引言 网络安全领域的快速发展为技术爱好者提供了广阔的学习与实践平台。本文旨在为初学者提供一个由浅入深的学习路线图&#xff0c;特别是在建立必要的基础知识上。 第一阶段&#xff1a;基础知识建设 黑客技术的有效学习需要在多个核心领域内建立坚实的基础。以下是初学者…
阅读更多...
OpenAIGPT-4.5提前曝光？

OpenAIGPT-4.5提前曝光？

OpenAI GPT-4.5的神秘面纱&#xff1a;科技界的震撼新篇章 在人工智能的世界里&#xff0c;每一次技术的飞跃都不仅仅是一次更新&#xff0c;而是对未来无限可能的探索。近日&#xff0c;科技巨头OpenAI似乎再次站在了这场革命的前沿&#xff0c;其潜在的新产品——GPT-4.5 Tur…
阅读更多...
[Java基础面试题] volatie 与 synchronized

[Java基础面试题] volatie 与 synchronized

1. 说一下 volatie 在Java中&#xff0c;volatile 关键字用于修饰变量&#xff0c;表示该变量是易变的&#xff0c;其值可能会被不同的线程修改。使用volatile关键字声明的变量具有两个特性&#xff1a; 原子性&#xff1a;volatile 变量的读写操作都是原子性的&#xff0c;即…
阅读更多...
MySQL事务--隔离级别

MySQL事务--隔离级别

1 事务的隔离级别 事务的隔离级别是数据库管理系统&#xff08;DBMS&#xff09;提供的一种机制&#xff0c;用于控制并发事务之间的相互影响程度。隔离级别决定了一个事务对于其他事务所做的修改是否可见&#xff0c;以及在多个事务并发执行时可能出现的各种问题的程度。 常…
阅读更多...
基于CANoe从零创建以太网诊断工程（3）—— Port Configuration 选项

基于CANoe从零创建以太网诊断工程（3）—— Port Configuration 选项

&#x1f345; 我是蚂蚁小兵&#xff0c;专注于车载诊断领域&#xff0c;尤其擅长于对CANoe工具的使用&#x1f345; 寻找组织 &#xff0c;答疑解惑&#xff0c;摸鱼聊天&#xff0c;博客源码&#xff0c;点击加入&#x1f449;【相亲相爱一家人】&#x1f345; 玩转CANoe&…
阅读更多...
【Linux —— 再谈软硬链接】

【Linux —— 再谈软硬链接】

Linux —— 再谈软硬链接 再识软硬链接用ln -s指令创建软链接用ln指令创建硬链接 软硬链接的特征软硬链接的作用(使用场景)软链接快捷方式 硬链接1. 节省空间2. 备份和同步3. 数据一致性4. 避免意外删除 为什么硬链接不能链接目录示例&#xff1a;假设硬链接可以链接目录循环引…
阅读更多...
最新文章

Copyright @ 2022~2023