【C++】学习笔记——智能指针

news2025/3/3 5:51:18

文章目录

  • 二十一、智能指针
    • 1. 内存泄漏
    • 2. 智能指针的使用及原理
      • RAII
      • 智能指针的原理
      • auto_ptr
      • unique_ptr
      • shared_ptr
      • shared_ptr的循环引用
      • weak_ptr
      • 删除器
  • 未完待续

二十一、智能指针

1. 内存泄漏

在上一章的异常中，我们了解到如果出现了异常，会中断执行流，跳转到catch处。但是这种情况非常不好，如果我们跳过了内存释放的代码，就会导致内存泄漏。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。
虽然我们可以通过异常的再次抛出来解决，但是终究是比较麻烦。

如何避免内存泄露呢？

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。但这只是理想状态，仍有问题出现内存泄漏，需要智能指针来保障。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 使用内存泄漏工具检测。

内存泄漏非常常见，解决方案分为两种：①事前预防型。如智能指针等。②事后查错型。如内存泄漏检测工具。

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

RAII

RAII（Resource Acquisition Is Initialization）是一种 利用对象生命周期来控制程序资源 （如内存、文件句柄、网络连接、互斥量等等）的简单技术。我们可以使用对象来管理资源，在创建对象的时候获取资源，销毁对象的时候释放资源。

#include <iostream>
using namespace std;

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr
{
public:
	// 构造函数获取资源
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	// 析构函数释放资源
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
		cout << "~SmartPtr()" << endl;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		// 抛出个C++异常标准库里的异常类型
		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;
}

在这里插入图片描述
我们发现即使出现了异常，也成功把资源给回收了，这种方式就是 RAII 技术。
这种做法有两大好处：①不需要显式地释放资源。②采用这种方式，对象所需的资源在其生命期内始终保持有效。

智能指针的原理

智能指针就是借助的 RAII 思想来实现的。但是上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。还得需要将* 、->重载下，才可让其像指针一样去使用。

#include <iostream>
using namespace std;

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr
{
public:
	// 构造函数获取资源
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

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

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

	// 析构函数释放资源
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
		cout << "~SmartPtr()" << endl;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		// 抛出个C++异常标准库里的异常类型
		throw invalid_argument("除0错误");
	return a / b;
}

void Func()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);

	// 使其具有指针的行为
	*sp1 += 10;
	SmartPtr<pair<string, int>> sp3(new pair<string, int>);
	sp3->second = 1;
	sp3.operator->()->first = "hello";

	cout << div() << endl;
}

int main()
{
	try
	{
		Func();
	}
	// 使用异常标准库的基类获取
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

故智能指针的特性：①RAII特性。②重载operator*和opertaor->，具有像指针一样的行为。

auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。需要注意的是，auto_ptr运行拷贝构造和赋值重载，但是 他会把旧的指针置空 。

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

int main()
{
	auto_ptr<int> sp1(new int);
	auto_ptr<int> sp2(sp1);


	*sp2 = 10;
	cout << *sp2 << endl;
	cout << *sp1 << endl;

	return 0;
}

在这里插入图片描述
在这里插入图片描述
auto_ptr的模拟实现：

namespace my
{
	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 = nullptr;
			}
			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的特性，会将旧指针置空，所以一般都不会用这个。

unique_ptr

unique_ptr解决了auto_ptr的缺点，因为unique_ptr直接就是禁止拷贝构造以及复制重载。非常简单粗暴。
unique_ptr的模拟实现：

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

namespace my
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}

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

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

		// delete掉拷贝构造和复制重载
		unique_ptr(const unique_ptr<T>&sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
	private:
		T* _ptr;
	};
}

由于unique_ptr的特性，一个资源只能被一个指针所指向。

shared_ptr

unique_ptr虽然解决了auto_ptr的问题，但是限制太大了，如果非要多个指针指向同一块资源的话就没办法，于是C++又提供了新的智能指针——shared_ptr。
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。最后一个指针释放资源。
那我们如何实现这个方法呢？怎么定义引用计数？使用局部变量吗？当然不可以，因为这样会导致每个对象里面都有自己独立的引用计数，失去了意义。静态变量吗？也不行。因为静态会导致类中只能存在1份，即只能对一个资源有效，多个资源就无法通过一个静态变量来管理。
那怎么办？我们可以和智能指针一样，构造时创建一个引用计数，析构时释放引用计数。
shared_ptr模拟实现：

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

namespace my
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		shared_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			// 拷贝构造使引用计数+1
			++(*_pcount);
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			// 自己给自己赋值没意义
			if (_ptr != sp._ptr)
			{
				// 使原来的引用计数-1
				release();

				_ptr = sp._ptr;
				_pcount = sp._pcount;

				// 新的引用计数+1
				++(*_pcount);
			}

			return *this;
		}

		// 资源释放
		void release()
		{
			// 引用计数变成0就释放资源
			if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

		int use_count()
		{
			return *_pcount;
		}

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

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

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		// 引用计数变量
		int* _pcount;
	};
}

shared_ptr的循环引用

根据上面来看，shread_ptr似乎以及非常完善了，真的是这样吗？我们来看看下面这个场景：

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;

	ListNode(int data = 0)
		:_data(data)
	{}

	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	shared_ptr<ListNode> node1(new ListNode(10));
	shared_ptr<ListNode> node2(new ListNode(20));

	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;
}

在这里插入图片描述
我们发现引用数没错，但是并没有释放资源。这是为什么呢？因为node1和node2析构时，引用计数-1，但是分别还有node1->next以及node2->prev还指向两个节点，因此引用计数并没有变成 0。引用计数不是0就不会析构释放资源，这就是shared_ptr的循环引用问题。
在这里插入图片描述

weak_ptr

上面的shared_ptr循环引用的问题可以使用weak_ptr解决。weak_ptr并不会增加引用计数。并不是全部替换，节点本身都还是shread_ptr，但是节点的前驱指针和后继指针改成了weak_ptr。

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

struct ListNode
{
	int _data;
	// 这里替换成不会增加引用计数的 weak_ptr
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;

	ListNode(int data = 0)
		:_data(data)
	{}

	~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;
}

在这里插入图片描述
这样，只有被shared_ptr指向的节点才会增加引用计数。

删除器

智能指针的释放都是使用 delete 来释放的，与 delete 匹配的是 new，如果不是new出来的对象如何通过智能指针管理呢？比如malloc，或者new[]等等，这样的若是使用delete来释放资源就会出现大问题！该怎么办呢？其实shared_ptr设计了一个删除器来解决这个问题。

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <memory>
using namespace std;

// 仿函数的删除器
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

int main()
{
	FreeFunc<int> freeFunc;
	std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);

	DeleteArrayFunc<int> deleteArrayFunc;
	std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);

	std::shared_ptr<int> sp4(new int[10], [](int* p){delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p){fclose(p); });

	return 0;
}

在这里插入图片描述
只要在定义的时候在后面跟上删除器（删除的方式）就可以使用了。

未完待续

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

4.5、作业管理

4.5、作业管理

几乎不太会考 作业的状态 作业&#xff1a;系统为完成一个用户的计算任务&#xff08;或一次事务处理&#xff09;所做的工作总和。例如&#xff0c;对用户编写的源程序&#xff0c;需要经过编译、连接、装入以及执行等步骤得到结果&#xff0c;这其中的每一个步骤称为作业步…
阅读更多...
【附安装包】CentOS7(Linux)详细安装教程(手把手图文详解版)

【附安装包】CentOS7(Linux)详细安装教程(手把手图文详解版)

目前流行的虚拟机软件有VMware、Virtual Box和Virtual PC等等&#xff0c;其中最常用的就是VMware。 而centos是Linux使用最广泛的版本之一。 教程开始教程有许多不完备之处&#xff0c;大佬请忽略。。。 1.安装VMware 首先需要准备VMware的安装包以及Ubuntu的ISO镜像&#…
阅读更多...
Shell编程——基础语法（2）和 Shell流程控制

Shell编程——基础语法（2）和 Shell流程控制

文章目录 基础语法&#xff08;2&#xff09;echo命令read命令printf命令test命令 Shell流程控制if-else语句for 循环while 语句until 循环case ... esac跳出循环 基础语法&#xff08;2&#xff09; echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似&#xff0c;都是用于…
阅读更多...
文档管理系统哪个好？优质8款系统深度比较

文档管理系统哪个好？优质8款系统深度比较

本文将分享8款文档管理系统&#xff1a;PingCode、Worktile、金山文档、腾讯文档、飞书文档、石墨文档、Confluence、Google Drive。 在寻找合适的文档管理系统时&#xff0c;你是否感到困惑和不安&#xff1f;市场上众多选项让人难以抉择&#xff0c;尤其是当你希望找到既能提…
阅读更多...
springCloud组件专题（五） --- seata

springCloud组件专题（五） --- seata

一.Seata介绍 1. seata是什么 是一款开源的分布式事务解决方案&#xff0c;供了 AT、TCC、SAGA 和 XA 事务模式。 2.分布式事务中的概念 2.1. 二阶段提交 二阶段提交的含义就是将事务的提交分成两个步骤&#xff0c;分别为&#xff1a; 准备阶段&#xff1a;事务协调者询问所…
阅读更多...
Django分页组件封装

Django分页组件封装

目录 1. 前言 2. 代码 3. 使用 3.1 view.py 3.2 list.html 1. 前言 在日常开发中&#xff0c;我们也许会遇到一页内容太多不够展示的问题&#xff0c;过于冗余。 此时&#xff0c;我们就需要进行分页&#xff0c;分页的方式有两种&#xff1a;1. ajax异步分页 2. 普通选…
阅读更多...
记一些零碎的只是点和一些安全工具的使用（这里建议将漏洞原理搞清楚，然后可以尝试手动和使用工具）

记一些零碎的只是点和一些安全工具的使用（这里建议将漏洞原理搞清楚，然后可以尝试手动和使用工具）

目录 信息收集 扫描端口 工具 nmap TxPortMap tideFinger fscan 漏洞扫描 目录扫描 利群使用 不同系统、不同框架的漏洞 OA weblogic Struts2 thinkphp漏洞 shiro 蚁剑使用 更高级的连接工具 免杀类型 主机端的免杀 流量层的免杀 安全设备 主机端安全设备…
阅读更多...
Docker容器数据库启动，如何用别名JAR jdbc:postgresql://别名:5432/postgres

Docker容器数据库启动，如何用别名JAR jdbc:postgresql://别名:5432/postgres

如果想了解为啥这样做得同学&#xff0c;请去看这个文章 Docker容器网络&#xff08;七&#xff09;_host.docker.internal-CSDN博客 因为docker0网络&#xff0c;需要用别名的话&#xff0c;还得在host文件加 dockerIp(172.0.0.2) 别名 怎么查&#xff0c; docker network …
阅读更多...
每日一题 ~ LCR 015. 找到字符串中所有字母异位词

每日一题 ~ LCR 015. 找到字符串中所有字母异位词

. - 力扣&#xff08;LeetCode&#xff09; 题目解析 题目要求找出字符串中所有的字母异位词。所谓字母异位词指的是两个字符串中字符出现的次数相同&#xff0c;但顺序可以不同的情况。 思路分析 固定窗口&#xff1a;使用滑动窗口技巧&#xff0c;窗口大小固定为待匹配字…
阅读更多...
Latex基本数学公式

Latex基本数学公式

LaTeX数学公式入门 LaTeX作为一种广泛使用的排版系统&#xff0c;尤其在学术界和科技领域&#xff0c;以其强大的排版能力和灵活性著称。而它的公式编辑能力更是让人叹为观止&#xff0c;经常与Markdown结合使用&#xff0c;以简化文档编写和公式展示的过程。 LaTeX 公式 L…
阅读更多...
数字的位操作——326、504、263、190、191、476、461、477、693

数字的位操作——326、504、263、190、191、476、461、477、693

326. 3 的幂&#xff08;简单&#xff09; 给定一个整数&#xff0c;写一个函数来判断它是否是 3 的幂次方。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 整数 n 是 3 的幂次方需满足&#xff1a;存在整数 x 使得 n 3x 示例 1&#xff1a; 输入&a…
阅读更多...
本地部署持续集成工具Jenkins并配置公网地址实现远程自动化构建

本地部署持续集成工具Jenkins并配置公网地址实现远程自动化构建

文章目录 前言1. 安装Jenkins2. 局域网访问Jenkins3. 安装 cpolar内网穿透软件4. 配置Jenkins公网访问地址5. 公网远程访问Jenkins6. 固定公网地址 前言 本文主要介绍如何在Linux CentOS 7中安装Jenkins并结合cpolar内网穿透工具实现远程访问管理本地部署的Jenkins服务. Jenk…
阅读更多...
DDR等长，到底长度差多少叫等长？

DDR等长，到底长度差多少叫等长？

DDR4看这一篇就够了 - 知乎 (zhihu.com) 【全网首发】DDR4 PCB设计规范&设计要点PCB资源PCB联盟网 - Powered by Discuz! (pcbbar.com) 终于看到较为权威的DDR4等长要求了: !!!! 依据这个要求&#xff0c;H616项目的等长线不合格&#xff1a;
阅读更多...
JazzEE（2）

JazzEE（2）

JazzEE&#xff08;2&#xff09; 8、异常引入try-catchcatch中如何处理异常try-catch-finally多重catch异常的分类throw和throws区别小案例 重载和重写的异常处理自定义异常 9、常用类包装类引入Integer String类String字符串内存 StringBuilder类可变和不可变常见方法StringB…
阅读更多...
SpringBoot整合Juint，ssm框架

SpringBoot整合Juint，ssm框架

目录 SpringBoot整合Juint 1.导入相关的依赖 2.创建测试类&#xff0c;使用注解SpringBootTest SpringBoot整合ssm框架 1.使用脚手架创建Spring项目 2.修改pom.xml 我先修改了SpringBoot的版本&#xff0c;修改为2.3.10.RELEASE&#xff0c;因为SpringBoot版本太高会出现…
阅读更多...
数据集——鸢尾花介绍和使用

数据集——鸢尾花介绍和使用

文章目录 一、鸢尾花数据集内容二、使用中常转换DataFrame 一、鸢尾花数据集内容 from sklearn import svm, datasets # 鸢尾花数据 iris datasets.load_iris() print(iris.data) X iris.data[:, :2] # 为便于绘图仅选择2个特征 y iris.target它包含了150个样本&#xff0c…
阅读更多...
3.8.语义分割

3.8.语义分割

语义分割 ​ 语义分割将图片中的每个像素分类到对应的类别(有监督学习) 1.图像分割和实例分割 图像分割将图像划分为若干组成区域&#xff0c;这类问题的方法通常利用图像中像素之间的相关性。它在训练时不需要有关图像像素的标签信息&#xff0c;在预测时也无法保证分割出的区…
阅读更多...
单细胞数据整合-去除批次效应harmony和CCA (学习)

单细胞数据整合-去除批次效应harmony和CCA (学习)

目录 单细胞批次效应学习 定义 理解 常用的去批次方法-基于Seurat 1&#xff09; Seurat-integration&#xff08;CCA&#xff09; 2&#xff09; Seurat-harmony 去批次代码 ①Seurat-integration&#xff08;CCA&#xff09; ②Seurat-harmony 单细胞批次效应学习 …
阅读更多...
【C++进阶学习】第十一弹——C++11（上）——右值引用和移动语义

【C++进阶学习】第十一弹——C++11（上）——右值引用和移动语义

前言&#xff1a; 前面我们已经将C的重点语法讲的大差不差了&#xff0c;但是在C11版本之后&#xff0c;又出来了很多新的语法&#xff0c;其中有一些作用还是非常大的&#xff0c;今天我们就先来学习其中一个很重要的点——右值引用以及它所扩展的移动定义 目录 一、左值引用和…
阅读更多...
AI智驾时代降临，端到端奏响“三重奏”

AI智驾时代降临，端到端奏响“三重奏”

“追上未来&#xff0c;抓住它的本质&#xff0c;把未来转变为现在”&#xff0c;俄国哲学家车尔尼雪夫斯曾这样描述未来。而走到今天的新能源汽车&#xff0c;其通向未来的本质就是做好智能化。 呐喊智能化的口号&#xff0c;从2023年延续到2024年。如今&#xff0c;智能化的…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023