【C++学习】C++智能指针：提高代码安全与性能的利器

文章标题

  • 智能指针的提出
  • 智能指针概念及使用
    • RAII
  • 智能指针的原理
  • C++库多种智能指针详解
    • 版本一：std::auto_ptr（C++98）
      • 1. std::auto_ptr 使用
      • 2. std::auto_ptr 原理
      • 3. std::auto_ptr 模拟实现
    • 版本二：unique_ptr (C++11)
      • 1. unique_ptr 的使用
      • 2. unique_ptr 的原理
      • 3. unique_ptr 的模拟实现
    • 版本三： std::shared_ptr(C++11)
  • 循环引用问题
      • weak_ptr的简单实现

智能指针的提出

在上篇所将的C++异常的文章中，有一个这样的场景：在new/malloc一个空间到delete/free释放这段资源之间，抛异常了，抛异常后直接跳到了catch语句，导致后面的delete/free语句没有执行到，会导致内存泄漏问题。
如下面这个场景：

  • 如下代码，当main函数调用func函数时，func函数内部给ptr开辟了一个空间，然后本来是要在func函数结束时将ptr空间释放的，但是中间如果抛了异常，接直接跳到了catch语句，导致ptr空间没有被释放，造成内存泄漏。
void func(){
	int* ptr = new int(2);   
	throw("异常");
	delete ptr;
}
int main()
{
	try {
		func();
	}catch (const char* s){
		cout << s << endl;
	}catch (...){
		cout << "未知异常" << endl;
	}
	return 0;
}

如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：
    这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条 智能指针 来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。

智能指针概念及使用

RAII

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

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

例如下面的例子：

//使用RAII思想设计的Smart_Pointer类
//将开好的资源给Smart_Pointer这个类创建一个对象，该对象里
//面是一个指针，这个对象来管理这个资源，当对象出了作用域，
//自动调用析构函数将资源清理释放，这样就不会有忘记释放资源
//或则上面中间异常导致delete不到的问题。
template<class T>
class Smart_Pointer{      
public:
	Smart_Pointer(T* ptr)
		:_ptr(ptr)
	{}
	~Smart_Pointer(){
		cout << "~Smart_Pointer" << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};

void func()
{
	Smart_Pointer<int> ptr(new int);   
	throw("异常");
}
int main(){
	try {
		func();
	}catch (const char* s){
		cout << s << endl;
	}catch (...){
		cout << "未知异常" << endl;
	}
	return 0;
}

智能指针的原理

上述的SmartPointer 还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：SmartPointer模板类中还得需要重载 * 、->，才可让其像指针一样去使用。

举个例子：

template<class T>
class Smart_Pointer
{
public:
	Smart_Pointer(T* ptr)
		:_ptr(ptr)
	{}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	~Smart_Pointer()
	{
		cout << "~Smart_Pointer" << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};
struct Date{
	Date(int year, int month, int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	~Date(){
		_year = _month = _day = 0;
	}
	int _year;
	int _month;
	int _day;
};
int main(){
	Smart_Pointer<int> ptr1(new int(1));
	cout << *ptr1 << endl;

	Smart_Pointer<Date> ptr2(new Date(2024, 4, 10));
	cout << ptr2->_year <<" " << ptr2->_month << " " << ptr2->_day << " " << endl;

	return 0;
}
//运行结果：
//1
//2024 4 10
//~Smart_Pointer
//~Smart_Pointer

但是，在实际中，我们可能将指针指向另一个空间，或指针间的拷贝，赋值等问题。
那么，智能指针的拷贝是需要深拷贝还是浅拷贝呢？

答案是：浅拷贝，因为智能指针的行为是模拟指针的行为。
之前学习的数据结构：比如list，vector等容器，特点是，利用这些资源存储管理数据，资源是自己的，拷贝时希望资源各自一份，不是同时利用同一份资源。
而智能指针与迭代器类似，资源不是自己的，代管资源，拷贝的时候希望直指向同一块资源；

那么智能指针的拷贝赋值等问题怎么解决呢？那我们就来看看C++中智能指针的历史发展。

C++库多种智能指针详解

  • 智能指针发展历史
  1. C++ 98 中产生了第一个智能指针auto_ptr.
  2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
  3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
  4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

版本一：std::auto_ptr（C++98）

文档链接：https://legacy.cplusplus.com/reference/memory/auto_ptr/?kw=auto_ptr

1. std::auto_ptr 使用

//包头文件memory
#include <memory>
int main()
{
	auto_ptr<int> ptr1(new int(10));
	auto_ptr<int> ptr2(new int(30));

	ptr1 = ptr2;   
	
	cout<<*ptr1<<endl;   //30
}

2. std::auto_ptr 原理

//当我们打印ptr1的内容时，运行报错
int main()
{
	auto_ptr<int> ptr1(new int(10));
	auto_ptr<int> ptr2(ptr1);

	cout << *ptr2 << endl;   //10
	//cout << *ptr1 << endl;    //会报错
}

在这里插入图片描述

运行调试时发现：

  • ptr2拷贝构造ptr1前：
    在这里插入图片描述

  • ptr2拷贝构造ptr1后
    在这里插入图片描述

  • 原理总结：
    根据调试结果可以分析出：
    std::auto_ptr是将被拷贝对象值拷贝给拷贝对象，然后将被拷贝对象置空处理；

3. std::auto_ptr 模拟实现

C++98版本的库中就提供了auto_ptr的智能指针。
auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份。

template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}
	auto_ptr(auto_ptr<T>& p)
	{
		_ptr = p._ptr;
		p._ptr = nullptr;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	~auto_ptr()
	{
		cout << "~Smart_Pointer" << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};

版本二：unique_ptr (C++11)

文档链接https://legacy.cplusplus.com/reference/memory/unique_ptr/?kw=unique_ptr
unique_ptr 版本的智能指针解决拷贝问题，简单粗暴，直接禁止拷贝和赋值。

1. unique_ptr 的使用

//包头文件memory
#include <memory>
int main()
{
	unique_ptr <int> ptr1(new int(10));
	//unique_ptr <int> ptr2(ptr1);   //编译报错
	
	cout << *ptr2 << endl;
	//cout << *ptr1 << endl;   
}

2. unique_ptr 的原理

原理：将unipue_ptr里面的拷贝构造与赋值运算符直接禁掉；

3. unique_ptr 的模拟实现

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

版本三： std::shared_ptr(C++11)

文档链接https://legacy.cplusplus.com/reference/memory/shared_ptr/?kw=unique_ptr
shared_ptr 允许拷贝。

  1. shared_ptr使用
int main()
{
	shared_ptr<int> ptr1(new int(10));
	shared_ptr<int> ptr2(ptr1);   //可拷贝构造
	shared_ptr<int> ptr3;

	ptr3 = ptr1;    //可赋值

	cout << *ptr2 << endl;
	cout << *ptr1 << endl;
	cout << *ptr3 << endl;
}
  1. shared_ptr原理

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

  • shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  • 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  • 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
  • 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

注意：share_ptr不允许隐式类型转换

思考：为什么不能用静态成员变量来计数？
如图所示：
在这里插入图片描述
解析：
当使用静态成员变量来计数，如图所示，开始时ptr1指向的一个空间，当用ptr1拷贝构造或则复制拷贝一个对象（ptr2）时，只需要_count++，当他们中的一个对象析构时，只需要_count–，当_count等于1时，说明只有一个对象管控着这个资源，当这个对象析构的时候，释放这块空间；

用静态成员变量虽然可以解决这种场景，但是当重新构造另一个对象的时候，该对象引用计数应该为1，但是这里却不为一。
所以用静态成员变量计数行不通。

解决方法：
对象里面存储一个int*的指针，构造的时候将这个空间的值初始化为1，当拷贝构造或者析构的时候，只需要++，–即可；
如图：
在这里插入图片描述

  1. shared_ptr模拟实现
template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr=nullptr)
		:_ptr(ptr)
		,_count(new int(1))
	{}
	//拷贝构造
	shared_ptr(shared_ptr<T>& p){
		assert(_ptr != p._ptr);
		_ptr = p._ptr;
		_count = p._count;
		++(*_count);
	}
	//ptr1=ptr2
	shared_ptr<T>& operator=(shared_ptr<T>& p)
	{
		//判断自己赋值给自己，或则间接自己给自己赋值
		if (_ptr != p._ptr){
			if (--(*_count) == 0){
				delete _ptr;
				delete _count;
			}
			_ptr = p._ptr;
			_count = p._count;
			++(*_count);
		}
		return *this;
	}
	int getconut()
	{
		return *(_count);
	}
	T& operator*(){
		return *_ptr;
	}
	T* operator->(){
		return _ptr;
	}
	~shared_ptr(){
		cout << "~shared_ptr()" << endl;
		//当引用计数--后为0，则释放
		if (--(*_count)==0)
		{
			delete _ptr;
			delete _count;
		}
	}
private:
	T* _ptr;
	int* _count;
};

循环引用问题

  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成员，所以这就叫循环引用，谁也不会释放。

在这里插入图片描述
解决方案：
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
原理就是，node1->_next = node2;和node2->_prev = node1;
时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

weak_ptr的简单实现

代码实现：

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}
	weak_ptr(shared_ptr<T>& p)
	{
		_ptr = p.get();
	}
	shared_ptr<T>& operator=(shared_ptr<T>&  p)
	{
		_ptr = p.get();
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	~weak_ptr()
	{
		cout << "~weak_ptr()" << endl;
		delete _ptr;	
	}
	private:
		T* _ptr;
	};

本章完~

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

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

相关文章

Unity之PUN实现多人联机射击游戏的优化（Section 3）

Unity之PUN实现多人联机射击游戏的优化（Section 3）

目录 &#x1f4a3;一、准备工作 &#x1f4a3;二、生成弹头脚本的编写 &#x1f4a3;三、实现发射和伤害同步 手雷都加了在给狗剩加个火箭筒不过分吧。效果看GIF动图&#xff0c;分别是单机和联机的效果。 添加火箭筒依旧是在原有的基础上更改&#xff0c;我查看火箭筒模型…
阅读更多...
基于STC12C5A60S2系列1T 8051单片机的LCD1602显示中文英文数字小数字库字符自定义字符的应用

基于STC12C5A60S2系列1T 8051单片机的LCD1602显示中文英文数字小数字库字符自定义字符的应用

基于STC12C5A60S2系列1T 8051单片机的LCD1602显示中文英文数字小数字库字符自定义字符的应用 STC12C5A60S2系列1T 8051单片机管脚图STC12C5A60S2系列1T 8051单片机I/O口各种不同工作模式及配置STC12C5A60S2系列1T 8051单片机I/O口各种不同工作模式介绍LCD1602字符型液晶显示器介…
阅读更多...
策略模式：灵活调整算法的设计精髓

策略模式：灵活调整算法的设计精髓

在软件开发中&#xff0c;策略模式是一种行为型设计模式&#xff0c;它允许在运行时选择算法的行为。通过定义一系列算法&#xff0c;并将每个算法封装起来&#xff0c;策略模式使得算法可以互换使用&#xff0c;这使得算法可以独立于使用它们的客户。本文将详细介绍策略模式的…
阅读更多...
算法——栈

算法——栈

T04BF &#x1f44b;专栏: 算法|JAVA|MySQL|C语言 &#x1faf5; 小比特 大梦想 此篇文章与大家分享关于栈相关的算法 如果有不足的或者错误的请您指出! 目录 1.删除字符中的所有相邻重复项1.1解析1.2题解 2.比较含退格的字符串2.1解析2.2题解 3.基本计算器II3.1解析3.2题解 4.…
阅读更多...
清明美食制作|“心灵护航，增能培力”残疾人职业能力提升培养

清明美食制作|“心灵护航，增能培力”残疾人职业能力提升培养

为提高残疾人的动手能力&#xff0c;提升个人的自身素质和自主就业创业能力&#xff0c;弘扬中华民族传统文化&#xff0c;临近清明之际&#xff0c;淳安县从益舍社会工作服务中心于浪川乡展开了以“品尝春天味道 制作清明粿 清明美食制作”为主题的清明节活动。 【清明粿制作】…
阅读更多...
【C语言__函数__复习篇1】

【C语言__函数__复习篇1】

目录 前言&#xff1a; 一、C语言中函数的概念 二、库函数 2.1 库函数的概念 2.2 怎样自学库函数——以sqrt函数为例 三、自定义函数 3.1 自定义函数的概念 3.2 自定义函数的语法形式 3.3 函数的实参 3.4 函数的形参 3.5 实参与形参的关系 3.6 return语句 3.7 数组传参 …
阅读更多...
O2OA开发平台如何查看数据表结构？

O2OA开发平台如何查看数据表结构？

在访问后端api地址&#xff0c;页面最下方有列示平台的各个服务&#xff0c;点击进入可查看具体的表内容 后端api地址&#xff1a; http://{hostIP}/x_program_center/jest/list.html 其中&#xff1a;{hostIP}为中心服务器所在域名或者IP地址 如下图&#xff1a;
阅读更多...
RA4000CE为汽车动力传动系统提供解决方案

RA4000CE为汽车动力传动系统提供解决方案

目前汽车电气化的水平越来越高&#xff0c;其中比较显著的一个发展方向就是将发动机管理系统和自动变速器控制系统&#xff0c;集成为动力传动系统的综合控制(PCM)。作为汽车动力的核心部件&#xff0c;通过电子系统的运用&#xff0c;将外部多个传感器和执行环节的数据进行统一…
阅读更多...
Go 自定义14位时间类型 yyyyMMddHHmmss

Go 自定义14位时间类型 yyyyMMddHHmmss

目录 功能 代码 功能 数据库或者接口时间类型&#xff0c;经常会使用14位的时间格式。每次都转换有点麻烦。可以自定义一个时间类型。 自定义类型需要实现json接口中的MarshalJSON与UnmarshalJSON两个函数&#xff0c;这样在做json编码解码时就会自动转为14位的时间格式了。…
阅读更多...
基于flutter3.x+window_manager+getx桌面端仿macOS系统

基于flutter3.x+window_manager+getx桌面端仿macOS系统

flutter3_macui桌面端仿macOS系统实战项目完结啦&#xff01; 原创研发flutter3.19dart3.3window_managergetx等技术构建桌面版macOS系统。支持自定义毛玻璃虚化背景、Dock菜单多级嵌套自由拖拽排序、可拖拽弹窗等功能。 支持macOS和windows11两种风格。 使用技术 编辑器&…
阅读更多...
【c++】优先级队列|反向迭代器（vector|list）

【c++】优先级队列|反向迭代器（vector|list）

优先级队列的常用函数的使用 #include<iostream> #include<queue> using namespace std;int main() {priority_queue<int>st;st.push(1);st.push(7);st.push(5);st.push(2);st.push(3);st.push(9);while (!st.empty()){cout << st.top() << &qu…
阅读更多...
【vue】watch 侦听器

【vue】watch 侦听器

watch&#xff1a;可监听值的变化&#xff0c;旧值和新值 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><titl…
阅读更多...
openstack之neutron介绍

openstack之neutron介绍

核心组件 neutron-server&#xff1a;提供API接口&#xff0c;把对应的api请求传给plugin进&#xff1b; neutron-plugin&#xff1a;管理逻辑网络状态&#xff0c;调用agent&#xff1b; neutron-agent&#xff1a;在provider network上创建网络对象&#xff1b; neutron-…
阅读更多...
【Vue】实现仿微信输入@出现选择框

【Vue】实现仿微信输入@出现选择框

<div style"padding: 10px 10px" class"editor"><el-inputresizetype"textarea":rows"4"clearableplaceholder"请输入您的问题.."v-model"requestParams.prompt"input"handleInput"keydown.na…
阅读更多...
C# WinForm —— 项目目录结构

C# WinForm —— 项目目录结构

1. WinForm 应用程序项目 Properties&#xff1a;属性文件夹存放了一个自动生成的类文件AssemblyInfo.cs&#xff0c;保存了一些应用程序集的一些信息引用存放了一些为应用程序提供所需的&#xff0c;某些功能的一些程序集&#xff08;dll文件&#xff09;等添加引用&#xff…
阅读更多...
Html网页小游戏源代码

Html网页小游戏源代码

Html网页小游戏源代码 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><title>Jello Jumping Game</title><meta name"viewport" content"widthdevice-width, initial-scale1"&…
阅读更多...
【安全】挖矿木马自助清理手册

【安全】挖矿木马自助清理手册

一、什么是挖矿木马 挖矿木马会占用CPU进行超频运算&#xff0c;从而占用主机大量的CPU资源&#xff0c;严重影响服务器上的其他应用的正常运行。黑客为了得到更多的算力资源&#xff0c;一般都会对全网进行无差别扫描&#xff0c;同时利用SSH爆破和漏洞利用等手段攻击主机。 …
阅读更多...
【AR】使用深度API实现虚实遮挡

【AR】使用深度API实现虚实遮挡

遮挡效果 本段描述摘自 https://developers.google.cn/ar/develop/depth 遮挡是深度API的应用之一。 遮挡&#xff08;即准确渲染虚拟物体在现实物体后面&#xff09;对于沉浸式 AR 体验至关重要。 参考下图&#xff0c;假设场景中有一个Andy&#xff0c;用户可能需要放置在包含…
阅读更多...
2024年蓝桥杯40天打卡总结

2024年蓝桥杯40天打卡总结

2024蓝桥杯40天打卡总结 真题题解其它预估考点重点复习考点时间复杂度前缀和二分的两个模板字符串相关 String和StringBuilderArrayList HashSet HashMap相关蓝桥杯Java常用算法大数类BigInteger的存储与运算日期相关考点及函数质数最小公倍数和最大公约数排序库的使用栈Math类…
阅读更多...
牛客周赛 Round 39（A,B,C,D,E,F,G）

牛客周赛 Round 39（A,B,C,D,E,F,G）

比赛链接 官方题解&#xff08;视频&#xff09; B题是个贪心。CD用同余最短路&#xff0c;预处理的完全背包&#xff0c;多重背包都能做&#xff0c;比较典型。E是个诈骗&#xff0c;暴力就完事了。F是个线段树。G是个分类大讨论&#xff0c;出题人钦定的本年度最佳最粪 题目…
阅读更多...
最新文章

Copyright @ 2022~2023