异常和智能指针

news2024/9/23 11:14:34

智能指针的认识

智能指针是一种C++语言中用于管理动态内存的工具，它们可以自动管理内存的分配和释放，从而避免内存泄漏和悬空指针等问题。智能指针可以跟踪指向的对象的引用次数，并在需要时自动释放被引用的内存，这极大地提高了内存管理的安全性和便利性。

C++标准库提供了三种类型的智能指针：

  • std::auto_ptr：管理权转移的思想，当进行赋值操作时会将原对象置空，而新对象指向该空间。
     

  • std::unique_ptr：独占型智能指针，表示它所指向的对象只能被一个指针拥有（即不能进行赋值），一旦该指针销毁，它所指向的对象也会被销毁。

  • std::shared_ptr：共享型智能指针，允许多个指针共同管理同一个对象，通过引用计数来跟踪对象的引用次数，当引用计数为0时自动释放对象内存。

 其实智能指针的使用是在异常时引出的，所以我们先了解一下异常：

异常

首先我们其实在堆区new空间的时候就见过异常，当我们想要开辟的空间太大而无法申请到就会抛异常：

概念

异常是我们处理错误的一种方式，当一个函数发现自己无法处理的错误时就可以抛出异常，让函数的直接或间接的调用者处理这个错误。

  • throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
  • catch: 在您想要处理问题的地方，通过异常处理程序捕获异常 catch 关键字用于捕获异常，可以有多个catch进行捕获。
  • try:try 块中放置可能抛出异常的代码,它后面通常跟着一个或多个 catch 块。

使用

double Division(int a, int b)//除法计算
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "不能除0";
	else
		return ((double)a / (double)b);
}
void Func()
{
	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}
int main()
{
	try 
	{
		Func();
	}
	catch (const char* errmsg)//抛出什么类型就捕获什么类型的数据
	{
		cout << errmsg << endl;
	}
	catch (...)//捕获抛出的未知异常
	{
		cout << "unkown exception" << endl;
	}
	return 0;
}

我们要知道当我们在throw抛出异常的时候，此时就会立马调用最近的catch进行，捕获异常， 如果没有调用到catch的话，或者catch的类型不匹配的话就会出现：

而且我们抛异常之后会被立马捕获异常，而这之间的代码并不会执行，直接就开始执行catch后续代码 。 但是也别忘了在此我们调用函数的过程中是创建了栈帧的，所以我们catch捕获异常后会销毁之前的栈帧空间。

实际中抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，抛出和捕获的匹配原则有个例外，并不都是类型完全匹配，可以抛出的派生类对象，使用基类捕获。这里就引入C++标准库异常体系了：

C++标准库异常体系

这个exception类就是所有标准C++异常的父类，所以当我们C++程序内部抛异常时都可以用父类对象接受捕获异常。

int main()
{
	try 
	{
		new int[7000000000];
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "Unkown Exception" << endl;
	}
	return 0;
}


 

异常规范 

//C++11
thread() noexcept;//表示函数体内一定不会抛异常，如果抛了就运行出错
thread (thread&& x) noexcept;

//C++98
void fun() throw();//表示函数体内一定不会抛异常，如果抛了也会捕获

// 这里表示这个函数会抛出A/B/C/D中的某种类型的异常
void fun() throw(A，B，C，D);
// 这里表示这个函数只会抛出bad_alloc的异常
void fun() throw (std::bad_alloc);

我们是否注意到异常的一点缺陷，当抛异常后就会立马执行到捕获异常的位置，这中途的栈帧都将销毁，而代码也不会执行，但是如果这之中需要我们释放堆区空间的话，那么就会造成内存泄漏。所以我们就有了智能指针的引出：

智能指针使用与实现

我们知道catch接受异常时可能会导致从堆区动态开辟的空间未释放从而造成内存泄漏，所以我们就采用了智能指针去构造的对象，然后在栈帧销毁的时候就会自动调用析构函数了，而不需要我们进行手动调用。

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;
	cout << div() << endl;//调用div()函数
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

这里我们发现会调用div函数，然后如果抛异常的话就会造成delete函数未执行，从而导致内存泄漏的情况，因此我们就通过智能指针的方式进行改造（以shared_ptr为例）：

template<class T>
class Smart_ptr
{
public:
	Smart_ptr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~Smart_ptr()
	{
		delete _ptr;
		cout << "delete[] " << _ptr << endl;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");

	return a / b;
}
void Func()
{
	Smart_ptr<int> p1 = new int;
	Smart_ptr<int> p2 = new int;

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

通过以上的方式，我们将需要创建的对象去构造智能指针，此时当战争销毁的时候就会自动调用类的析构函数，从而释放空间。而这种方式的原理就是就是RAII：

RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内
存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在
对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做
法有两大好处：

  1. 不需要显式地释放资源。
  2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。
     

 shared_ptr

template<class T>
class Smart_ptr
{
public:
	
	Smart_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		,_count(new int(1))
	{}

	Smart_ptr(const Smart_ptr<T>& tmp)//拷贝构造（浅拷贝）
		:_ptr(tmp._ptr)
		,_count(tmp._count)
	{
		(*_count)++;//引用计数++
	}

	Smart_ptr<T>& operator=(const Smart_ptr<T>& tmp)
	{
		if(_ptr!=tmp._ptr)//防止自己给自己赋值()
		{
			//this->~Smart_ptr();//没问题但是不好

			if (--(*_count) == 0)//该空间可能不仅被一个对象所指，所以当前的记数-1
			{
				delete[] _ptr;
				delete _count;
				//cout << "delete[] " << _ptr << endl;
			}

			_ptr = tmp._ptr;
			_count = tmp._count;
			(*_count)++;

			return *this;
		}
	}


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

	~Smart_ptr()
	{
		if (*_count > 1)
			(*_count)--;
		else
		{
			delete _ptr;
			delete _count;
			//cout << "delete[] " << _ptr << endl;
		}
	}
private:
	T* _ptr;
	int* _count;//引用计数(关键就是指针存放)
	//光整型存放会有问题，会导致拷贝构造后的数据不是同一个记数
};

虽然说shared_ptr可以解决这种问题，但是shared_ptr最大的缺陷就是循环引用，而对于循环引用问题的解决就引出了weak_ptr。先看一下什么是循环引用：

循环引用

循环引用是指在编程中，两个或多个对象相互引用，形成一个循环的引用链，导致它们无法被正常地回收或释放。

struct ListNode
{
	int val;
	Smart_ptr<ListNode> next;
	Smart_ptr<ListNode> pre;

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

void test()
{
	Smart_ptr<ListNode> n1(new ListNode);
	Smart_ptr<ListNode> n2(new ListNode);
	n1->next = n2;
	n2->pre = n1;
}
int main()
{
	test();

	return 0;
}

在该种情形时可以分析出：n1->next=n2;这段代码使得n2指针指向的空间计数为2,而n2->pre=n1；使得n1指向的空间记数也为2，而且当该栈帧空间销毁时会先析构n2这块空间，再析构n1这块空间：

    ~Smart_ptr()
	{
		if (*_count > 1)
			(*_count)--;
		else
		{
			delete _ptr;
			delete _count;
			//cout << "delete[] " << _ptr << endl;
		}
	}

当析构n2空间时会先引用计数--，然后发现n2该对象成员函数是两个内置类型，不做处理，所以就开始析构n1对象，同样是引用计数--，此时就程序结束了。

但是_next还指向下一个节点。而且_prev还指向上一个节点。从而导致堆区内存空间未释放所以造成了内存泄漏。所以想要正确释放空间就要析构n1的_next节点（释放n2）和n2的_pre节点（释放n1），但是_next是n1的成员，_pre又是n2的成员，所以想要析构_next和_pre的话就又要析构n1和n2，从而形成了闭环。

而以上情形就是循环引用。最终谁都不会释放，从而造成内存泄漏。

std::weak_ptr是一种用于解决shared_ptr相互引用时产生死锁问题的智能指针。也就是当多个对象指向同一空间时不会增加引用计数

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

此时的_next和_pre 的指针类型就可以是weak_ptr的类型：

定制删除器

当我们使用智能指针的时候其实都疏忽了一点，空间释放delete对象时的方式，当我们new的是单一的空间的时候就直接delete就行了，而当我们new的是一段连续的空间的时候就需要delete[]来释放空间，此时就很容易的联想到仿函数。我们库里的是采用重载构造函数模版的方式来解决问题：

所以我们就可以按照库的解决方式进行改造我们所写的代码：

namespace cr
{
    template<class T>
	class shared_ptr
	{
	public:

		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _count(new int(1))
		{}

		template<class D>//模版类型
		shared_ptr(T* ptr, D del)//重载构造函数
			: _ptr(ptr)
			, _count(new int(1))
			, _del(del)//设置为类成员用于析构调用
		{}

		shared_ptr(const shared_ptr<T>& tmp)//拷贝构造（浅拷贝）
			:_ptr(tmp._ptr)
			, _count(tmp._count)
		{
			(*_count)++;
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& tmp)
		{
			if (_ptr != tmp._ptr)//防止自己给自己赋值
			{
				if (--(*_count) == 0)
				{
					del(_ptr);//相当于调用operator()
					delete _count;
				}

				_ptr = tmp._ptr;
				_count = tmp._count;
				(*_count)++;

				return *this;
			}
		}

		~shared_ptr()
		{
			if (*_count > 1)
				(*_count)--;
			else
			{
				_del(_ptr);//相当于调用operator()
				delete _count;
			}
		}
	private:
		T* _ptr;
		int* _count;
		function<void(T*)> _del = [](T* ptr)->void {delete ptr; };//默认给缺省值
		//因为不知道_del的类型，采用function包装器包装，可以接受函数指针、lambda表达式、仿函数
	};
}

 主函数中进行测试调用：

template<class T>
struct del//仿函数
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
}; 
struct ListNode
{
	int val;
	cr::shared_ptr<ListNode> next;
	cr::shared_ptr<ListNode> pre;

	~ListNode()
	{
		cout << "~ListNode" << endl;
	}
};
int main()
{
	cr::shared_ptr<ListNode> p1(new ListNode[10],del<ListNode>());
	cr::shared_ptr<ListNode> p2(new ListNode[10],[](ListNode* ptr)->void{delete[]ptr; });
	cr::shared_ptr<ListNode> p3(new ListNode);
    
    return 0;
}

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

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

相关文章

w15php系列之基础类型

w15php系列之基础类型

一、计算100之内的偶数之和 实现思路 所有的偶数除2都为0 代码实现 <?php # 记录100以内的偶数和 $number1; $num0; while($number<100){if($number%20){ $num$number;}$number1; } echo $num; ?>输出的结果 二、计算100之内的奇数之和 实现思路 所有的奇数除…
阅读更多...
不可能得到的最短骰子序列

不可能得到的最短骰子序列

说在前面 &#x1f388;不知道大家对于算法的学习是一个怎样的心态呢&#xff1f;为了面试还是因为兴趣&#xff1f;不管是出于什么原因&#xff0c;算法学习需要持续保持。 题目描述 给你一个长度为 n 的整数数组 rolls 和一个整数 k 。你扔一个 k 面的骰子 n 次&#xff0c;…
阅读更多...
【华为OD机试真题2023CD卷 JAVAJS】两个字符串间的最短路径问题

【华为OD机试真题2023CD卷 JAVAJS】两个字符串间的最短路径问题

华为OD2023（C&D卷）机试题库全覆盖，刷题指南点这里 两个字符串间的最短路径问题 知识点数组动态规划字符串 时间限制：1s 空间限制：256MB 限定语言：不限 题目描述： 给定两个字符串，分别为字符串A与字符串B。例如A字符串为ABCABBA，B字符串为CBABAC可以得到下图m*n的二…
阅读更多...
算法与数据结构--二叉搜索树与自平衡二叉搜索树

算法与数据结构--二叉搜索树与自平衡二叉搜索树

0.字典&#xff08;即c的map&#xff09; 注&#xff1a;字典的 "member运算" 指的是检查字典中是否存在某个特定的键的操作&#xff0c;即查询操作。 如果我们使用数组来实现字典/map&#xff0c;虽然使用二分法查询也可以达到logn&#xff0c;但是的话插入和删除太…
阅读更多...
HAL库的常用库函数（根据学习而更新）

HAL库的常用库函数（根据学习而更新）

目录 一、常用的GPIO相关HAL库函数 1、GPIO的初始化 2、配置GPIO引脚输出电平 3、切换指定引脚的电平&#xff0c;电平的翻转 4、读取指定GPIO引脚的电平 5、结构体 GPIO_InitTypeDef &#xff08;引脚&#xff09;定义&#xff1a; 6、高低电平的表示 7、延时函数&…
阅读更多...
使用TLS/SSL Pinning保护安卓应用程序

使用TLS/SSL Pinning保护安卓应用程序

使用TLS/SSL Pinning保护安卓应用程序 在现代术语中&#xff0c;“SSL”&#xff08;安全套接层&#xff09;通常指的是“TLS”&#xff08;传输层安全&#xff09;。虽然 SSL 和 TLS 不是同一个东西&#xff0c;但 TLS 是 SSL 的改进和更安全的版本&#xff0c;并且在实践中已…
阅读更多...
【环境配置】虚拟环境配置

【环境配置】虚拟环境配置

创建虚拟环境 conda create -n pytorch python3.9安装成功提示 激活虚拟环境 activate pytorch安装pytorch 查看 python 版本——python 退出 python——exit() 对照 python 与 pytorch 的对应关系 pytorch 地址&#xff1a; https://pytorch.org/get-started/previous-…
阅读更多...
Web前端VScode/Vue3/git/nvm/node开发环境安装

Web前端VScode/Vue3/git/nvm/node开发环境安装

目录 1 基本配置 2 安装vscode 3 安装vue 4 配置bash 5 安装nvm 6 安装node 7 安装yarn 8 新建项目 9 运行helloworld 1 基本配置 本篇是为了做前端开发的环境而写。使用的操作系统是windows 10 64位 2 安装vscode 现在做vue和node基本就是vscode和webstorm&#x…
阅读更多...
添加调试日志，bug消失

添加调试日志，bug消失

参考&#xff1a;就删了个printf&#xff0c;代码崩了&#xff01; 1、运行报错代码 #include "stdio.h" #include "stdlib.h" #include "string.h"void func1() {int arr[10];memset(arr, 1, sizeof(arr)); }void func2() {int index;int* ar…
阅读更多...
《我在北京送快递》平凡隽永的时刻，对人生更具意义

《我在北京送快递》平凡隽永的时刻，对人生更具意义

《我在北京送快递》平凡隽永的时刻&#xff0c;对人生更具意义 胡安焉 文章目录 《我在北京送快递》平凡隽永的时刻&#xff0c;对人生更具意义[toc]摘录感悟 摘录 转“没有期限的承诺无疑就是委婉的拒绝” 转书友&#xff1a;亨利福特说&#xff0c;我聘的是一双手&#xff0…
阅读更多...
逆向P1P2总结

逆向P1P2总结

字节八位 word 16位 deword 32 位 00 00 00 e8 是存储32位信息的起点 不是程序运行的起点 为什么电脑有32位与64位之分 寻址宽度 以字节为单位 0xfffffff 1 就是最大容量 转为十进制为 4294967296 / 1024 &#xff08;k&#xff09;/1024 &#xff08;kb&#xff09;/ 1…
阅读更多...
Vue 封装echarts饼状图（Pie）组件

Vue 封装echarts饼状图（Pie）组件

目的&#xff1a;减少重复代码&#xff0c;便于维护 效果显示&#xff1a; 组件代码 <template><div class"ldw-data-content-box"><div class"ldw-chilren-box"><div class"title"><div>{{ title }}</div>…
阅读更多...
JavaScript进阶（事件+获取元素+操作元素）

JavaScript进阶（事件+获取元素+操作元素）

目录 事件基础 事件组成 执行事件的步骤 获取元素 根据ID获取元素 根据标签名获取元素 获取ol中的小li 类选择器&#xff08;html5新增的I9以上支持&#xff09; 获取body和html 操作元素 innerText和innerHtml 表单标签 样式属性操作 操作元素总结 事件基础 事…
阅读更多...
【C++】STL 容器 - list 双向链表容器 ① ( 容器特点 | 容器操作时间复杂度 | 构造函数 )

【C++】STL 容器 - list 双向链表容器 ① ( 容器特点 | 容器操作时间复杂度 | 构造函数 )

文章目录 一、 list 双向链表容器简介1、容器特点2、容器操作时间复杂度3、遍历访问5、头文件 二、 list 双向链表容器 构造函数1、默认无参构造函数2、创建包含 n 个相同元素的 list 双向链表3、使用初始化列表构造 list 双向链表4、使用另外一个 list 容器 构造 list 双向链表…
阅读更多...
图解机器学习神器：Scikit-Learn

图解机器学习神器：Scikit-Learn

算法进阶 ​​本文详解 Scikit-learn 工具库的用法&#xff0c;覆盖机器学习基础知识、SKLearn讲解、SKLearn三大核心API、SKLearn高级API等内容。 https://www.showmeai.tech/article-detail/203 我们在上一篇SKLearn入门与简单应用案例 [1] 里给大家讲到了 SKLearn 工具的基…
阅读更多...
reactive和TypeScript标注数据类型-ts使用方法

reactive和TypeScript标注数据类型-ts使用方法

一、vite项目中<script setup lang"ts"> : lang"ts" 是表明支持ts校验&#xff08;ts 全称typescript,是es6语法&#xff0c;是javascript的超集强类型编程语言&#xff0c;类似java&#xff0c;定义变量类型后&#xff0c;赋值类型不一致&#xff0…
阅读更多...
Redis 内存爆了？使用 Python 分析一下哪些 Key 占用空间比较大

Redis 内存爆了？使用 Python 分析一下哪些 Key 占用空间比较大

大家好，我是水滴~~ 在这篇文章中，我们将探讨如何使用Python来分析Redis中哪些Key占用空间较大，以便识别和优化内存使用。 《Python入门核心技术》专栏总目录・点这里 文章目录 1. 前言2. 代码与解析2.1 安装依赖2.2 完整代码2.3 代码解析3. Excel 分析4. 总结1. 前言 Redi…
阅读更多...
（2023|CVPR，Corgi，偏移扩散，参数高斯分布，弥合差距）用于文本到图像生成的偏移扩散

（2023|CVPR，Corgi，偏移扩散，参数高斯分布，弥合差距）用于文本到图像生成的偏移扩散

Shifted Diffusion for Text-to-image Generation 公众&#xff1a;EDPJ&#xff08;添加 VX&#xff1a;CV_EDPJ 或直接进 Q 交流群&#xff1a;922230617 获取资料&#xff09; 目录 0. 摘要 1. 简介 2. 方法 2.1 偏移扩散 3. 实验 3.1 无监督文本到图像生成 3.2 无…
阅读更多...
免费IDEA插件推荐-Apipost-Helper

免费IDEA插件推荐-Apipost-Helper

IDEA插件市场中的API调试插件不是收费&#xff08;Fast Request &#xff09;就是不好用&#xff08;apidoc、apidocx等等&#xff09;今天给大家介绍一款国产的API调试插件&#xff1a;Apipost-Helper&#xff0c;完全免费且好看好用&#xff01; 这款插件由Apipost团队开发的…
阅读更多...
C++ 比 C语言的新增的特性 1

C++ 比 C语言的新增的特性 1

1. C是C的增强 1.1 C是静态类型的语言&#xff0c;具有严格的数据类型检查 1.1.1 c 因为const修饰的变量不允许修改&#xff0c;但是只给了警告&#xff0c;不严谨 const int a10;a20; //报错int *p&a;*p20;//a的值&#xff1f; test1.c:6:9: warning: initialization dis…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023