C++11（中）：智能指针

智能指针

    • 1.内存泄漏
      • 1.1内存泄漏的概念以及危害
      • 1.2内存泄漏的场景
      • 1.3如何避免内存泄漏
    • 2.智能指针的使用及原理
      • 2.1RAII
      • 2.2智能指针的原理
      • 2.3 std::auto_ptr
      • 2.4 定制删除器
      • 2.5 std::unique_ptr
      • 2.6 std::shared_ptr
      • 2.7 std::weak_ptr
        • 2.7.1 std::shared_ptr的循环引用
        • 2.7.2 循环引用的解决

1.内存泄漏

1.1内存泄漏的概念以及危害

内存泄漏的概念：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。


1.2内存泄漏的场景

  • 内存申请了忘记释放
void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
}
  • 异常安全问题，异常会导致执行流乱跳，有可能调用申请了空间，但因为抛出异常而没有得到正常释放，就会导致内存泄漏。
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	int* p1 = new int;
	int* p2 = new int;
	//div抛出异常，执行流跳到main函数导致p1、p2指向空间未释放
	cout << div() << endl;  
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

1.3如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。
  2. 使用内存泄漏工具检测。
  3. 采用RAII思想或者智能指针来管理资源，也是本文重点。



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

2.1RAII

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

把获取的资源交给一个对象（栈上的），接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
        cout << "资源已释放" << endl;
    }
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> sp1(new int);
    SmartPtr<int> sp2(new int);
    cout << div() << endl;
}

int main()
{
    try {
        Func();
    }
    catch (const exception& e)
    {
        cout << e.what() << endl;
    }
    return 0;
}

2.2智能指针的原理

  • RAII特性
  • 重载operator*和opertaor->，可像指针一样使用。
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
        : _ptr(ptr)
    {}
    ~SmartPtr()
    {
        if (_ptr)
            delete _ptr;
    }
    T& operator*() { return *_ptr; }
    T* operator->() { return _ptr; }
private:
    T* _ptr;
};
struct Date
{
    int _year;
    int _month;
    int _day;
};
int main()
{
    SmartPtr<int> sp1(new int);
    *sp1 = 10;
        cout << *sp1 << endl;
    SmartPtr<Date> sparray(new Date);
    // 需要注意的是这里应该是sparray.operator->()->_year = 2018;
    // 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
    sparray->_year = 2018;
    sparray->_month = 1;
    sparray->_day = 1;
}

2.3 std::auto_ptr

C++的各种智能指针不同点在于对于拷贝的处理，因为指针本身是支持拷贝的。

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。

auto_ptr的实现原理：管理权转移的思想。
下面简化模拟实现了一份auto_ptr来了解它的原理：

namespace SmartPtr
{
    template<class T>
    class auto_ptr
    {
    public:
        auto_ptr(T* ptr)
            :_ptr(ptr)
        {}
        auto_ptr(auto_ptr<T>& sp)
            :_ptr(sp._ptr)
        {
            // 管理权转移
            sp._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;
        }
        ~auto_ptr()
        {
            if (_ptr)
            {
                cout << "delete:" << _ptr << endl;
                delete _ptr;
            }
        }
        // 像指针一样使用
        T& operator*()
        {
            return *_ptr;
        }
        T* operator->()
        {
            return _ptr;
        }
    private:
        T* _ptr;
    };
}
// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr
int main()
{
     std::auto_ptr<int> sp1(new int);
     std::auto_ptr<int> sp2(sp1); // 管理权转移

     // sp1悬空,存在野指针访问
     *sp2 = 10;
     cout << *sp2 << endl;
     cout << *sp1 << endl;
     return 0;
}

auto_ptr的总结：
建议别用，泄漏空间程序还不会挂，起码比访问野指针好点。


2.4 定制删除器

交给智能指针管理的资源，有可能是数组，也可能是单个对象，我们需要在析构的时候进行正确的释放，就需要定制删除器。

定制删除器的实现：

  1. 可用仿函数，仿函数增加对应的模板参数即可。
  2. 也可用包装器，本文采用的就是包装器。

代码看后面的unique_ptr和shared_ptr，这里写太冗余。


2.5 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理：

// C++11库才更新智能指针实现
// C++11出来之前，boost搞除了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr
// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace SmartPtr
{
    template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			cout << "release:" << (int*)_ptr << endl;  //打印
			delete _ptr;
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		unique_ptr(auto_ptr<T>& up) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
	private:
		T* _ptr;
	};
}

int main()
{
     /*bit::unique_ptr<int> sp1(new int);
     bit::unique_ptr<int> sp2(sp1);*/

     std::unique_ptr<int> sp1(new int);
     //std::unique_ptr<int> sp2(sp1);

     return 0;
}

unique_ptr的总结：不需要拷贝的情况用。


2.6 std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr。

拷贝的要点：

  1. 对标指针，拷贝完看到的应该是同一份资源。
  2. 直接值拷贝不可行，会多次析构导致崩溃，应该采用引用计数。

引用计数：

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  4. 如果引用计数不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
namespace SmartPtr
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _count_ptr(new int(1))
		{}

		template<class D>  
		shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _count_ptr(new int(1))
			,_del(del)
		{}

		shared_ptr(shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_count_ptr = sp._count_ptr;
			(*_count_ptr)++;  //引用计数加一即可
		}

		void release()
		{
			if (--(*_count_ptr) == 0)
			{
				cout << "release:" << (int*)_ptr << endl;  //打印
				_del(_ptr);
				delete _count_ptr;
				_count_ptr = nullptr;
				_ptr = nullptr;
			}
		}

		~shared_ptr()
		{
			release();
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (sp._ptr != _ptr)
			{
				release();
				_ptr = sp._ptr;
				_count_ptr = sp._count_ptr;
				(*_count_ptr)++;
			}
			return *this;
		}

		T* get() const
		{
			return _ptr;
		}

		int use_count() const
		{
			return *_count_ptr;
		}
	private:
		T* _ptr;
		int* _count_ptr;
		function<void(T*)> _del = [](T* ptr) { delete[] ptr; };
	};

	void test_shared_ptr1()
	{
		shared_ptr<int> sp1 = new int(1);
		const shared_ptr<int> sp2 = new int(3);
		shared_ptr<int> sp3(new int[10], [](int* ptr) { delete[] ptr; });
		//shared_ptr<int> sp3 = sp2;
		//sp2 = sp1;
		//sp3 = sp1;
	}
}

shared_ptr的总结：需要拷贝的情况用。


2.7 std::weak_ptr

2.7.1 std::shared_ptr的循环引用

先看代码，下面代码存在内存泄漏：

struct ListNode
{
    int _data;
    shared_ptr<ListNode> _prev;
    shared_ptr<ListNode> _next;
};
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;
}

循环引用分析：

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

在这里插入图片描述


2.7.2 循环引用的解决

weak_ptr：只负责存储数值，不参与资源管理，支持用shared_ptr构造。

namespace SmartPtr
{
	//weak_ptr就如同普通的指针一样，不参与资源的管理
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}

		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		weak_ptr<T>& operator=(shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
	private:
		T* _ptr;
	};
}

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

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

相关文章

go语言（二十一）---- channel的关闭

go语言（二十一）---- channel的关闭

channel不像文件一样需要经常去关闭&#xff0c;只有当你确实没有任何发送数据了&#xff0c;或者你想显示的结束range循环之类的&#xff0c;才去关闭channel。关闭channel后&#xff0c;无法向channel再发送数据&#xff0c;&#xff08;引发pannic错误后&#xff0c;导致接收…
阅读更多...
力扣20、有效的括号（简单）

力扣20、有效的括号（简单）

1 题目描述 图1 题目描述 2 题目解读 给定的字符串只包含括号&#xff0c;判断这个字符串中的括号是否按照正确顺序出现&#xff0c;即这个字符串是否有效。 3 解法一&#xff1a;栈 C的STL中的stack&#xff0c;在解题时非常好用。 3.1 解题思路 使用栈stk&#xff0c;并枚举…
阅读更多...
使用 Ant Design Pro 初始化前端项目

使用 Ant Design Pro 初始化前端项目

一、使用 pro-cli 来快速的初始化脚手架 1. 打开终端&#xff0c;输入命令 # 使用 npm npm i ant-design/pro-cli -g # create 后面加要初始化的项目名称 pro create leapi-frontend 2. 报错 PS D:\code> pro create leapi-frontend pro : 无法加载文件 D:\tools\nodejs…
阅读更多...
Java基础—面向对象OOP—18三大特性:封装、继承与多态

Java基础—面向对象OOP—18三大特性:封装、继承与多态

由于本身理解还不是很到位&#xff0c;所以写的很绕&#xff0c;后续待补充优化 1、封装&#xff08;底层&#xff09;&#xff1a;该露的露&#xff0c;该藏的藏 高内聚&#xff1a;类的内部数据操作细节自己完成&#xff0c;不允许外部干涉低耦合&#xff1a;仅暴露少量的方…
阅读更多...
计算机二级C语言的注意事项及相应真题-6-程序填空

计算机二级C语言的注意事项及相应真题-6-程序填空

目录 51.将参数num按升序插入到数组xx中52.在数组中找出两科成绩之和最高的学生并返回其在数组中的下标53.删除所有串长超过k的字符串&#xff0c;输出剩下的字符串54.根据所给的一组学生的成绩&#xff0c;计算出平均成绩&#xff0c;并计算低于平均成绩的学生的平均成绩55.将…
阅读更多...
Python算法题集_找到字符串中所有字母异位词

Python算法题集_找到字符串中所有字母异位词

本文为Python算法题集之一的代码示例 题目438&#xff1a;找到字符串中所有字母异位词 说明&#xff1a;给定两个字符串 s 和 p&#xff0c;找到 s 中所有 p 的 异位词 的子串&#xff0c;返回这些子串的起始索引。不考虑答案输出的顺序。 异位词 指由相同字母重排列形成的字…
阅读更多...
【c++】高精度算法（洛谷刷题2024）玩具谜题详解（含图解）

【c++】高精度算法（洛谷刷题2024）玩具谜题详解（含图解）

系列文章目录 第三题&#xff1a;玩具谜题 视频讲解&#xff1a;http://【洛谷题单 - 算法 - 高精度】https://www.bilibili.com/video/BV1Ym4y1s7BD?vd_source66a11ab493493f42b08b31246a932bbb 文章目录 目录 系列文章目录 文章目录 前言 一、题目分析以及思考 二、代码…
阅读更多...
查询redis路径，清除redis缓存

查询redis路径，清除redis缓存

查询redis路径 1、执行ps -ef | grep redis 命令&#xff0c;结果如下&#xff08;记住PID&#xff09; 2、执行ps -u 系统用户名&#xff0c;进一步确定进程id, 我这里的系统用户名是root&#xff0c;执行ps -u root&#xff0c;结果如下&#xff1a; 结合1的操作结果图可知…
阅读更多...
SERVLET生命周期API

SERVLET生命周期API

SERVLET生命周期API 在servlet的生命周期中，将发生创建Servlet上下文、创建会话、向Servlet上下文添加属性等各种事件。在servlet的生命周期内发生事件时，Web容器将通知侦听器类。要接收事件的通知，侦听器类需要扩展Servlet API的侦听器接口。 1. 事件类型 servlet生命周期…
阅读更多...
关于如何利用ChatGPT提高编程效率的

关于如何利用ChatGPT提高编程效率的

自从去年ChatGPT3.5推出以后&#xff0c;这一年时间在编程过程中我也在慢慢熟悉人工智能的使用&#xff0c;目前来看即使是免费的ChatGPT3.5对于编程效率的提升也是有很大帮助的&#xff0c;虽然在使用过程中确实出现了一些问题&#xff0c;本文记录下我的一些心得体会和用法。…
阅读更多...
Peter算法小课堂—二叉堆（优先队列）

Peter算法小课堂—二叉堆（优先队列）

课前小视频&#xff1a;(7 封私信 / 62 条消息) 看动画&#xff0c;学算法&#xff0c;C实现建立二叉堆&#xff0c;优先队列和堆排序的基础 - 知乎 (zhihu.com) 二叉堆&#xff08;优先队列&#xff09; 大家想想&#xff0c;什么数据结构能做到插入&#xff08;删除&#x…
阅读更多...
IDEA 构建开发环境

IDEA 构建开发环境

本博客主要讲解了如何创建一个Maven构建Java项目。&#xff08;本文是创建一个用Maven构建项目的方式&#xff0c;所以需要对Maven有一定的了解&#xff09; IDEA 构建开发环境 一、创建一个空工程二、构建一个普通的Maven模块 一、创建一个空工程 创建一个空的工程 * 设置整…
阅读更多...
声音模拟训练

声音模拟训练

环境配置 参考文章&#xff1a; https://github.com/SUC-DriverOld/so-vits-svc-Chinese-Detaild-Documents 1:打开CMD nvidia-smi.exe 查询显卡 cuda VERSION:12.3 2:打开https://pytorch.org/get-started 我的系统是12.3 3&#xff1a;使用google 搜索 nvidia develope…
阅读更多...
哈希概念 | 哈希函数 | 哈希冲突 | 哈希桶实现 | 哈希线性探测代码实现 | 闭散列 | 开散列 | 字符串哈希算法

哈希概念 | 哈希函数 | 哈希冲突 | 哈希桶实现 | 哈希线性探测代码实现 | 闭散列 | 开散列 | 字符串哈希算法

文章目录 1.哈希概念2.哈希冲突3.解决哈希冲突3.1.闭散列3.2.开散列 4.字符串哈希算法 1.哈希概念 顺序结构以及平衡树中&#xff0c;元素关键码与其存储位置之间没有对应的关系&#xff0c;因此在查找一个元素时&#xff0c;必须要经过关键码的多次比较。如果一个顺序结构&am…
阅读更多...
80.网游逆向分析与插件开发-背包的获取-自动化助手显示物品数据1

80.网游逆向分析与插件开发-背包的获取-自动化助手显示物品数据1

内容参考于&#xff1a;易道云信息技术研究院VIP课 上一个内容&#xff1a;升级Notice类获得背包基址-CSDN博客 码云地址&#xff08;ui显示角色数据 分支&#xff09;&#xff1a;https://gitee.com/dye_your_fingers/sro_-ex.git 码云版本号&#xff1a;3be017de38c50653b…
阅读更多...
BGP：04 fake-as

BGP：04 fake-as

使用 fake-as 可以将本地真实的 AS 编号隐藏&#xff0c;其他 AS 内的对等体在指定本端对等体所在的AS 编号时&#xff0c;应该设置成这个伪AS 编号。 这是实验拓扑&#xff0c;IBGP EBGP 邻居都使用物理接口来建立 基本配置&#xff1a; R1: sys sysname R1 int loo0 ip add…
阅读更多...
面了快手电商数据分析师岗(实习)，被问的汗流浃背。。。。

面了快手电商数据分析师岗(实习)，被问的汗流浃背。。。。

最近技术群的一位同学&#xff0c;分享了他面试快手数据分析师岗(实习)的经验。我看了一下面试题&#xff0c;说实话内容不难&#xff0c;他直言没有认真准备。 今天整理后分享给大家&#xff0c;如果你对这块面试感兴趣&#xff0c;可以文末加入我们的面试、技术群 内容 1&…
阅读更多...
时序预测 | Python基于Multihead-Attention-TCN-LSTM的时间序列预测

时序预测 | Python基于Multihead-Attention-TCN-LSTM的时间序列预测

目录 效果一览基本介绍程序设计参考资料 效果一览 基本介绍 时序预测 | Python基于Multihead-Attention-TCN-LSTM的时间序列预测 Multihead-Attention-TCN-LSTM&#xff08;多头注意力-TCN-LSTM&#xff09;是一种结合了多个注意力机制、时序卷积网络&#xff08;TCN&#xff0…
阅读更多...
解决方案｜构建生物医学科技桥梁：镭速客户案例分享

解决方案｜构建生物医学科技桥梁：镭速客户案例分享

随着生物科技在医学领域的快速发展&#xff0c;数据传输在实现医疗创新和科学研究中的重要性变得日益突出。数据不仅庞大&#xff0c;而且高度敏感&#xff0c;传统的数据传输方式已经无法满足医学行业对高效、快速的数据交流需求。 如今市场上备受关注的解决方案是基于UDP传输…
阅读更多...
计算机毕业设计 基于SpringBoot的校园闲置物品交易系统的设计与实现 Java实战项目 附源码+文档+视频讲解

计算机毕业设计 基于SpringBoot的校园闲置物品交易系统的设计与实现 Java实战项目 附源码+文档+视频讲解

博主介绍&#xff1a;✌从事软件开发10年之余&#xff0c;专注于Java技术领域、Python人工智能及数据挖掘、小程序项目开发和Android项目开发等。CSDN、掘金、华为云、InfoQ、阿里云等平台优质作者✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精…
阅读更多...
最新文章

Copyright @ 2022~2023