C++ —— 智能指针

C++ —— 智能指针

文章目录

  • C++ —— 智能指针
  • 一、为什么需要使用智能指针？
  • 二、内存泄漏
    • 什么是内存泄漏？
    • 内存泄漏的危害？
    • 内存泄漏分类
  • 三、智能指针的使用及原理
    • 1. RAII
    • 2. 智能指针的原理
  • 三、智能指针的缺陷及其发展
    • 3.1 std::auto_ptr
    • 3.2 std::unique_ptr
    • 3.3 std::shared_ptr
    • 3.4 std::weak_ptr
  • 四、C++11和boost中智能指针的关系
  • 五、总结

一、为什么需要使用智能指针？

我们观察如下代码，并思考代码中提到的三个问题

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

通过分析代码我们可以发现，在一些情况下，由于抛异常与捕获异常的跳转情况，在抛异常前申请的内存空间存在没有回收的可能
例如上述代码中p1与p2指针都是我们先new出来的对象，在调用div函数时候，一但我们输入的除数为0，此时程序就会抛异常，程序就会直接跳转到catch语句，进行捕获异常的操作，而本应该进行的delete p1与delete p2语句则被跳过了，此时就出现了内存泄漏的情况，而智能指针的提出就是用来解决这个问题的

二、内存泄漏

什么是内存泄漏？

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

内存泄漏的危害？

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

内存泄漏分类

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

  1. 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak

  2. 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

三、智能指针的使用及原理

1. RAII

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

这种做法有两大好处：

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

2. 智能指针的原理

智能指针实际上是RAII思想的一种具体实现，简单来讲就是将我们自主开辟的内存空间交给一个类的对象来管理，利用类的特性，在对象构造时获取资源来管理，在对象析构的时候会自动调用析构函数，此时释放我们开辟的资源

template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete[] _ptr;
		cout << "delete[] " << _ptr << endl;
	}
private:
	T* _ptr;
};

有了智能指针我们再运行上述内存泄漏的代码看看

double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw invalid_argument("Division by zero condition!");
	}

	return (double)a / (double)b;
}

void Func()
{
	// RAII
	SmartPtr<int> sp1(new int[10]);
	SmartPtr<double> sp2(new double[10]);

	int len, time;
	cin >> len >> time;
	cout << Division(len, time) << endl;
}

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

	return 0;
}

在这里插入图片描述
可以发现此时内存泄漏的问题解决了
但作为一个指针，还需要有 *、-> 等功能，才能真正称得上是一个指针

我们将其完善一下

template<class T>
class SmartPtr
{
public:
	// RAII
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete[] _ptr;
		cout << "delete[] " << _ptr << endl;
	}

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

private:
	T* _ptr;
};

总结一下智能指针的原理：

  1. RAII特性
  2. 重载operator*和opertaor->，具有像指针一样的行为

三、智能指针的缺陷及其发展

基本的智能指针框架我们都完成了，不仅能自动释放空间，还具备有指针的基本属性
但上文中我们实现的SmartPtr还是具有一定的缺陷，我们将智能指针拷贝赋值时，就存在了两个智能指针对象共同管理一片空间，这也意味着同一块申请的空间可能会被析构两次，此时BUG就出现了

而下面将逐步分析C++如何优化解决这一问题的

3.1 std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针

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

namespace Tlzns
{
	template<class T>
	class auto_ptr
	{
	public:
		// RAII
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}


		~auto_ptr()
		{
			delete[] _ptr;
			cout << "delete[] " << _ptr << endl;
		}

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

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

		//1.自己给自己赋值
		//2.自己原来有值改为其他的
		auto_ptr<T> operator= (auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				//释放原有管理空间
				delete _ptr;

				_ptr = ap->_ptr;
				ap->_ptr = nullptr;
			}

			return *this;
		}

	private:
		T* _ptr;
	};

}

3.2 std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理

简单粗暴，直接杜绝拷贝

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

		~unique_ptr()
		{
			delete[] _ptr;
			cout << "delete[] " << _ptr << endl;
		}

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

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


		//C++11
		unique_ptr(unique_ptr<T>& up) = delete;
		unique_ptr<T> operator= (unique_ptr<T>& up) = delete;

	//private:
	//	//C++98
	//	//1、只声明不实现
	//	// 2、限定为私有
	//	unique_ptr(const unique_ptr<T>& up);
	//	unique_ptr<T>& operator=(const unique_ptr<T>& up);

	private:
		T* _ptr;
	};

}

3.3 std::shared_ptr

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

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源
例如：老板晚上在下班之前都会通知，让最后走的员工记得把门锁下

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

		shared_ptr(shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			,_pcount(sp._pcount)
		{
			(*_pcount)++;
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				cout << "delete->" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

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

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

		//自己给自己赋值的两种情况
		//1. sp1 = sp1
		//2. sp1 = sp2
		shared_ptr<T> operator= (shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//若原有引用计数为0，释放原有空间
				release();

				_ptr = sp->_ptr;
				_pcount = sp->_pcount;
				(*_pcount)++;
			}

			return *this;
		}

	private:
		T* _ptr;
		int* _pcount;
	};

}

这份自实现的shared_ptr用引用计数解决了重复析构的问题，但上述代码中并不支持delete一个数组或者容器，单单只支持delete一个对象 不支持delete[]，为改进这个问题C++11中新增了一个构造函数，可以手动编写del的规则
在这里插入图片描述
我们用function接收析构规则，并提供默认的析构规则来解决问题

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

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


		shared_ptr(shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			(*_pcount)++;
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				cout << "delete->" << _ptr << endl;
				//delete _ptr;
				_del(_ptr);
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

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

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

		//自己给自己赋值的两种情况
		//1. sp1 = sp1
		//2. sp1 = sp2
		shared_ptr<T> operator= (shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//若原有引用计数为0，释放原有空间
				release();

				_ptr = sp->_ptr;
				_pcount = sp->_pcount;
				(*_pcount)++;
			}

			return *this;
		}

	private:
		T* _ptr;
		int* _pcount;
		//用function接收析构规则，并提供默认的析构规则
		function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};
}

我们可以进行测试

struct s
{
	~s()
	{
		cout << "delete" << endl;
	}
};

int main()
{
	Tlzns::shared_ptr<s> ap1(new s[10], [](s* p) {delete[] p; });
	return 0;
}

在这里插入图片描述
至此shared_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);

	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和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成员，所以这就叫循环引用，双方都在等对方释放，所以谁也不会释放

在这里插入图片描述

为了解决这个问题 C++提出了weak_ptr

3.4 std::weak_ptr

注意：weak_ptr其实已经脱离了RAII的思想，weak_ptr的提出只是为了解决shared_ptr循环引用的问题

解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr
原理：node1->_next = node2;与node2->_prev = node1;时，weak_ptr的_next和_prev不会增加node1和node2的引用计数

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

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


		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			(*_pcount)++;
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				cout << "delete->" << _ptr << endl;
				//delete _ptr;
				_del(_ptr);
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

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

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

		//自己给自己赋值的两种情况
		//1. sp1 = sp1
		//2. sp1 = sp2
		shared_ptr<T> operator= (const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				//若原有引用计数为0，释放原有空间
				release();

				_ptr = sp->_ptr;
				_pcount = sp->_pcount;
				(*_pcount)++;
			}

			return *this;
		}

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pcount;
		//用function接收析构规则，并提供默认的析构规则
		function<void(T*)> _del = [](T* ptr) {delete 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;
	};

}

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

在这里插入图片描述

四、C++11和boost中智能指针的关系

  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中的实现的

boost标准库就像是C++的先行版本，用于测试开发新的功能

五、总结

在这里插入图片描述

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

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

相关文章

华为笔记本matebook pro X如何扩容 C 盘空间

华为笔记本matebook pro X如何扩容 C 盘空间

一、前提条件 磁盘扩展与合并必须是相邻分区空间&#xff0c;且两个磁盘类型需要相同。以磁盘分区为 C 盘和 D 盘为例&#xff0c;如果您希望增加 C 盘容量&#xff0c;可以先将 D 盘合并到 C 盘&#xff0c;然后重新创建磁盘分区&#xff0c;分配 C 盘和 D 盘的空间大小。 访…
阅读更多...
Element ui 的组件弹窗 el-dialog点击的时候全屏变灰问题解决

Element ui 的组件弹窗 el-dialog点击的时候全屏变灰问题解决

最近在使用Element UI 的弹窗组件的时候发现这个组件各种的应用都没有问题&#xff0c;数据和元素的应用都是正确的但是在点击显示这个弹窗的时候全屏幕都会变灰。 这也不是因为增加了modal 遮挡幕的问题&#xff0c;在经过不断的排查代码的时候基本排除了代码的问题&#xf…
阅读更多...
利用外卖系统源码构建高效的在线订餐平台

利用外卖系统源码构建高效的在线订餐平台

在当今数字化时代&#xff0c;外卖服务已成为人们日常生活中不可或缺的一部分。为了满足用户需求&#xff0c;许多创业者和企业都希望搭建自己的在线订餐平台。利用现有的外卖系统源码&#xff0c;可以快速构建一个高效、安全的在线订餐平台。本文将介绍如何利用外卖系统源码来…
阅读更多...
Qt SQLite3数据库加密 QtCipherSqlitePlugin

Qt SQLite3数据库加密 QtCipherSqlitePlugin

在客户端软件开发过程中&#xff0c;基本都会涉及到数据库的开发。QT支持的数据库也有好几种&#xff08;QSQLITE, QODBC, QODBC3, QPSQL, QPSQL7&#xff09;&#xff0c;SQLite就是其中之一&#xff0c;但这个 SQLite 是官方提供的开源版本&#xff0c;没有加密功能的。如果对…
阅读更多...
k8s 进阶实战笔记 | 应用的蓝绿、金丝雀发布笔记

k8s 进阶实战笔记 | 应用的蓝绿、金丝雀发布笔记

文章目录 应用的蓝绿、金丝雀发布笔记应用升级策略停机升级滚动更新蓝绿发布金丝雀发布 应用的蓝绿、金丝雀发布笔记 应用升级策略 Deployment.spec.strategy 设置 Recreate&#xff1a;同时删除所有副本&#xff0c;停机升级策略 不存在新老版本共存 存在某个时间段服务不可…
阅读更多...
麒麟系统—— openKylin 安装 redis

麒麟系统—— openKylin 安装 redis

麒麟系统—— openKylin 安装 redis 一、准备工作1. 确保麒麟系统 openKylin 已经安装完毕。 二、下载安装文件三、解压安装解压安装 四、配置与运行修改配置文件以配置文件运行 五、加入到服务中最终&#xff1a;介绍配置的其他参数使用 Redis是一种开源的、基于内存的高速缓存…
阅读更多...
MySQL原理（一）架构组成（2）逻辑模块组成

MySQL原理（一）架构组成（2）逻辑模块组成

总的来说&#xff0c;MySQL可以看成是二层架构&#xff0c;第一层我们通常叫做SQL Layer&#xff0c;在MySQL数据库系统处理底层数据之前的所有工作都是在这一层完成的&#xff0c;包括权限判断&#xff0c;sql解析&#xff0c;执行计划优化&#xff0c;query cache的处理等等&…
阅读更多...
Vue之初识Vue CLI 脚手架

Vue之初识Vue CLI 脚手架

Vue CLI 是Vue 官方提供的一个全局命令工具 可以帮助我们快速创建一个开发Vue项目的标准化基础架子。【集成了webpack配置】 脚手架有什么好处&#xff1f; 1.开箱即用&#xff0c;零配置 2.内置 babel 等工具 3.标准化 使用步骤: 1.全局安装(一次):yarn globaladd vue/cli …
阅读更多...
私有化部署pdf工具箱

私有化部署pdf工具箱

功能简介 用于合并/拆分/旋转/移动PDF及其页面的完全交互式GUI。 将多个 PDF 合并到一个生成的文件中。 将 PDF 拆分为多个文件&#xff0c;并按指定的页码或将所有页面提取为单个文件。 将 PDF 页面重新组织为不同的顺序。 以 90 度为增量旋转 PDF。 删除页面。 多页布局…
阅读更多...
STM32学习笔记一——初识STM32

STM32学习笔记一——初识STM32

目录 一、什么是ARM 二. Cortex 内核 三.什么是STM32 四.STM32核心板原理图&#xff1a; 五.STM32的内部结构&#xff1a; 六.stm32系统结构简化图 STM32基本原理分析&#xff1a; 七.典型型号——STM32F103ZET6 stm32——32位单片机&#xff08;数据总线是32位的&am…
阅读更多...
文献速递：人工智能医学影像分割--- 深度学习分割骨盆骨骼：大规模CT数据集和基线模型

文献速递：人工智能医学影像分割--- 深度学习分割骨盆骨骼：大规模CT数据集和基线模型

文献速递&#xff1a;人工智能医学影像分割— 深度学习分割骨盆骨骼&#xff1a;大规模CT数据集和基线模型 我们为大家带来人工智能技术在医学影像分割上的应用文献。 人工智能在医学影像分析中发挥着至关重要的作用&#xff0c;尤其体现在图像分割技术上。这项技术的目的是准…
阅读更多...
Flask 入门

Flask 入门

1. 关于 Flask Flask诞生于2010年&#xff0c; Armin Ronacher的一个愚人节玩笑。不过现在已经是一个用python语言基于Werkzeug工具箱编写的轻量级web开发框架&#xff0c;它主要面向需求简单&#xff0c;项目周期短的小应用。 Flask本身相当于一个内核&#xff0c;其他几乎所…
阅读更多...
前端大屏展示可视化——地图的绘制（持续更新）

前端大屏展示可视化——地图的绘制（持续更新）

一、ECharts 1、安装 npm install echarts2、引入 import * as echarts from echarts;3、渲染 3.1、前期准备&#xff0c;基础配置 // 地图实例 const myChart ref(null); // 地图配置 const option reactive({tooltip: {trigger: item,formatter: function (params) {re…
阅读更多...
WebSocket 整合 记录用法

WebSocket 整合 记录用法

WebSocket 介绍 WebSocket 是基于tcp的一种新的网络协议,可以让浏览器 和 服务器进行通信,然后区别于http需要三次握手,websocket只用一次握手,就可以创建持久性的连接,并进行双向数据传输 Http和WebSocket的区别 Http是短连接,WebSocket’是长连接Http通信是单向的,基于请求…
阅读更多...
第十一篇【传奇开心果系列】BeeWare的Toga开发移动应用示例：Briefcase和Toga 哥俩好

第十一篇【传奇开心果系列】BeeWare的Toga开发移动应用示例：Briefcase和Toga 哥俩好

传奇开心果博文系列 系列博文目录BeeWare的Toga开发移动应用示例系列博文目录一、前言二、Briefcase和toga各自的主要功能分别介绍三、使用Toga 开发移动应用Briefcase工具是最佳拍档四、Briefcase搭档Toga创建打包发布联系人移动应用示例代码五、运行测试打包发布六、归纳总结…
阅读更多...
OCP NVME SSD规范解读-8.SMART日志要求-1

OCP NVME SSD规范解读-8.SMART日志要求-1

4.8.5章节SMART / Health Information Requirements详细规定了NVMe固态硬盘对SMART&#xff08;Self-Monitoring, Analysis and Reporting Technology&#xff09;和健康信息日志页面的支持要求&#xff0c;以确保设备能够准确报告其运行状态和预测潜在故障。 SLOG-1&#xff1…
阅读更多...
使用Docker安装Jenkins，并能够在该Jenkins中使用Docker

使用Docker安装Jenkins，并能够在该Jenkins中使用Docker

1. 构建Dockerfile 试错1 参考https://medium.com/manav503/how-to-build-docker-images-inside-a-jenkins-container-d59944102f30 按照文章里所介绍的&#xff0c;实现在Jenkins容器环境中依然能够调用Docker&#xff0c;需要做到以下几步 下载Jenkins镜像将环境中的docke…
阅读更多...
设计模式——2_0 职责链（Chain of Responsibility）

设计模式——2_0 职责链（Chain of Responsibility）

楼下一个男人并得要死&#xff0c;那家隔壁的一家唱着留声机&#xff0c;对面是弄孩子。楼上有两人狂笑&#xff1b;还有打牌声&#xff0c;河中的船上有女人哭她死去的母亲。人类的悲欢并不相通&#xff0c;我只觉得他们吵闹 ——鲁迅 定义 使多个对象都有机会处理请求&#…
阅读更多...
Go语言中HTTP代理的请求和响应过程

Go语言中HTTP代理的请求和响应过程

在Go语言中&#xff0c;HTTP代理的实现涉及对请求和响应的拦截、转发和处理。下面将详细介绍这个过程。 请求过程&#xff1a; 客户端发起请求&#xff1a;客户端&#xff08;例如浏览器或其他应用程序&#xff09;发送HTTP请求到代理服务器。建立连接&#xff1a;代理服务器…
阅读更多...
fgets函数和fputs函数的使用

fgets函数和fputs函数的使用

----由于本人使用的是大白话来讲解fgets和fputs函数的使用&#xff0c;所以可能有些部分可能会有些不准确&#xff08;见谅&#xff09;&#xff0c;如果想十分严谨的了解fgets和fputs函数&#xff0c;可以移步其他文章。 -----那么不废话&#xff0c;直接开始 1.fgets函数 &a…
阅读更多...
最新文章

Copyright @ 2022~2023