C++11: 智能指针

news2025/4/8 20:34:05

C++11: 智能指针

  • （一）智能指针原理
    • 1.RAll
    • 2.智能指针
  • (二)C++11 智能指针
    • 1. auto_ptr
    • 2. unique_ptr
    • 3. shared_ptr
    • 4. weak_ptr
  • （三）shared_ptr中存在的问题
    • std::shared_ptr的循环引用
  • （四）删除器
  • （五）C++11和boost中智能指针的关系

（一）智能指针原理

我们在编写代码时，会因为各种问题而没有做到内存释放，造成内存泄漏的问题。
即使我们对申请的内存空间记着匹配的去释放，但是如果碰上异常时，就算注意释放了，还是可能会出问题。

因此我们采用RAII思想或者智能指针来管理资源

1.RAll

RAII是什么:

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

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。

这种做法有两大好处：

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
    SmartPtr(T* ptr = nullptr)
       : _ptr(ptr)
   {}
    ~SmartPtr()
   {
        if(_ptr)
            delete _ptr;
   }
    
private:
    T* _ptr;
};

2.智能指针

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

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

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

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

(二)C++11 智能指针

1. auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。auto_ptr的实现原理：管理权转移的思想。

  • 下面简化模拟实现了一份xrw::auto_ptr来了解它的原理
namespace xrw
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~auto_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}

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


		auto_ptr& operator=(const auto_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				if (_ptr)
				{
					delete _ptr;
				}

				_ptr = sp._ptr;
				sp._ptr = nullptr;
			}

			return *this;
		}

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

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

实际上，auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。
因为当一个对象的管理权转移后，该对象不能再用对原来管理的资源进行访问，否则程序就会崩溃。

2. unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝

下面简化模拟实现unique_ptr

namespace xrw
{
	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;
		}
		unique_ptr(const unique_ptr<T>&sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
	private:
		T* _ptr;
	};
}

该智能指针简单粗暴，但是不能实现拷贝赋值的操作。

3. shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr.
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

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

下面是shared_ptr的一个简化的模拟实现

设计思路：
这里提供一个整形指针_count来进行引用计数，当进行拷贝赋值等操作时，我们只需要这个指针的地址拷贝过去，然后将这个指针所指向的内容加1即可。若当进行析构时，对_count所指向的内容减1，并且判断*_count是否等于0，若等于0才真正的进行内存释放

template<class T>
class shared_ptr
{
public:

private:
	T* _ptr;
	int* _count;  //引用计数
};

整体代码：

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


	~shared_ptr()
	{
		if (--(*_count) == 0)
		{
			delete _ptr;
			delete _count;
		}
	}

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


	shared_ptr& operator=(const shared_ptr<T>& sp)
	{
		if (--(*_count) == 0)
		{
			delete _ptr;
			delete _count;
		}

		_ptr = sp._ptr;
		_count = sp._count;
		++(*_count);
	}

	T* get() const
	{
		return _ptr;
	}

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

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

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

4. weak_ptr

weak_ptr的存在就是为了解决shared_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& operator= (const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

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

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

（三）shared_ptr中存在的问题

std::shared_ptr的循环引用

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{

	}

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

	}

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

循环引用分析：

  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就可以了

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

weak_ptr不参与引用计数。

（四）删除器

上面的模拟实现的shared_ptr代码中我们都默认是 new出来的对象通过智能指针管理，但要是不是new出来的对象我们如果处理呢？因此我们引入了一个删除器。

其实删除器的本质和仿函数类似，我们提供一个包装器对象，该对象用来接收（仿函数，lambda表达式等）特等的删除方式。

template<class T>
class shared_ptr
{
public:


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

因此当我们不能只用delete来释放内存的情况出现时，使用shared_ptr智能指针就必须要主动提供一个仿函数（可以是lambda表达式等）来处理删除的情况。

  • 所以我们需要提供一个构造函数来接受这个仿函数
template<class D>
shared_ptr(T* ptr,D del)
	:_ptr(ptr)
	, _count(new int(1))
	,_del(del)
{}

对此删除器我们需要做出改动的就只有析构，拷贝，赋值函数，其实就是将原有的delete，变成调用删除器罢了

~shared_ptr()
{
	if (--(*_count) == 0)
	{
		_del(_ptr);
		delete _count;
	}
}

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

shared_ptr& operator=(const shared_ptr<T>& sp)
{
	if (--(*_count) == 0)
	{
		_del(_ptr);
		delete _count;
	}

	_ptr = sp._ptr;
	_count = sp._count;
	++(*_count);
}

用包装器的思路来处理删除器十分巧妙。

下面是使用这个删除器的例子：

class A
{
public:
	A(int a = 0)
		:_a(a)
	{
		cout << "A(int a = 0)" << endl;
	}

	~A()
	{
		cout << this;
		cout << " ~A()" << endl;
	}
	//private:

	int _a;
};

template<class T>
struct DeleteArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};


int main()
{
	xrw::shared_ptr<A> sp1(new A[10], DeleteArray<A>());
	xrw::shared_ptr<A> sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
	xrw::shared_ptr<A> sp3(new A);  //这里是new一个对象，可以使用默认的delete

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

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

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

相关文章

从零实现本地大模型RAG部署

从零实现本地大模型RAG部署

1. RAG概念 RAG&#xff08;Retrieval-Augmented Generation&#xff09;即检索增强生成&#xff0c;是一种结合信息检索与大型语言模型&#xff08;大模型&#xff09;的技术。从外部知识库&#xff08;如文档、数据库或网页&#xff09;中实时检索相关信息&#xff0c;并将其…
阅读更多...
【Linux系统篇】：探索文件系统原理--硬件磁盘、文件系统与链接的“三体宇宙”

【Linux系统篇】：探索文件系统原理--硬件磁盘、文件系统与链接的“三体宇宙”

✨感谢您阅读本篇文章&#xff0c;文章内容是个人学习笔记的整理&#xff0c;如果哪里有误的话还请您指正噢✨ ✨ 个人主页&#xff1a;余辉zmh–CSDN博客 ✨ 文章所属专栏&#xff1a;Linux篇–CSDN博客 文章目录 一.认识硬件--磁盘物理存储结构1.存储介质类型2.物理存储单元3…
阅读更多...
Tracing the thoughts of a large language model 简单理解

Tracing the thoughts of a large language model 简单理解

Tracing the thoughts of a large language model 这篇论文通过电路追踪方法（Circuit Tracing）揭示了大型语言模型Claude 3.5 Haiku的内部机制，其核心原理可归纳为以下几个方面： 1. 方法论核心：归因图与替换模型 替换模型（Replacement Model） 使用跨层转码器（CLT）将原…
阅读更多...
OpenCV边缘检测技术详解：原理、实现与应用

OpenCV边缘检测技术详解：原理、实现与应用

概述 边缘检测是计算机视觉和图像处理中最基本也是最重要的技术之一&#xff0c;它通过检测图像中亮度或颜色急剧变化的区域来识别物体的边界。边缘通常对应着场景中物体的物理边界、表面方向的变化或深度不连续处。 分类 OpenCV提供了多种边缘检测算法&#xff0c;下面我们介…
阅读更多...
BN 层做预测的时候, 方差均值怎么算

BN 层做预测的时候, 方差均值怎么算

✅ 一、Batch Normalization&#xff08;BN&#xff09;回顾 BN 层在训练和推理阶段的行为是不一样的&#xff0c;核心区别就在于&#xff1a; 训练时用 mini-batch 里的均值方差&#xff0c;预测时用全局的“滑动平均”均值方差。 &#x1f9ea; 二、训练阶段&#xff08;Trai…
阅读更多...
JS 其他事件类型

JS 其他事件类型

页面加载 事件 window.addEvent() window.addEventListener(load,function(){const btn document.querySelector(button)btn.addEventListener(click,function(){alert(按钮)})})也可以给其他标签加该事件 HTML加载事件 找html标签 也可以给页面直接赋值
阅读更多...
AI Agent设计模式五：Orchestrator

AI Agent设计模式五：Orchestrator

概念 &#xff1a;中央任务调度中枢 ✅ 优点&#xff1a;全局资源协调&#xff0c;确保任务执行顺序❌ 缺点&#xff1a;单点故障风险&#xff0c;可能成为性能瓶颈 import operator import osfrom langchain.schema import SystemMessage, HumanMessage from langchain_opena…
阅读更多...
MySQL基础 [三] - 数据类型

MySQL基础 [三] - 数据类型

目录 数据类型分类 ​编辑 数值类型 tinyint bit 浮点类型 float decimal 字符串类型 char varchar varchar和char的比较和选择 日期和时间类型 enum和set enum类型 set类型 enum和set的类型查找 数据类型分类 数值类型 tinyint TINYINT[(M)] [UNSIGNED]是 …
阅读更多...
不用训练，集成多个大模型产生更优秀的输出

不用训练，集成多个大模型产生更优秀的输出

论文标题 Collab: Controlled Decoding using Mixture of Agents for LLM Alignment 论文地址 https://arxiv.org/pdf/2503.21720 作者背景 JP摩根&#xff0c;马里兰大学帕克分校&#xff0c;普林斯顿大学 动机 大模型对齐&#xff08;alignment&#xff09;的主要目的…
阅读更多...
随笔1 认识编译命令

随笔1 认识编译命令

1.认识编译命令 1.1 解释gcc编译命令: gcc test1.cpp -o test1 pkg-config --cflags --libs opencv 命令解析&#xff1a; gcc&#xff1a;GNU C/C 编译器&#xff0c;用于编译C/C代码。 test1.cpp&#xff1a;源代码文件。 -o test1&#xff1a;指定输出的可执行文件名为t…
阅读更多...
Hyperlane 框架路由功能详解：静态与动态路由全掌握

Hyperlane 框架路由功能详解：静态与动态路由全掌握

Hyperlane 框架路由功能详解&#xff1a;静态与动态路由全掌握 Hyperlane 框架提供了强大而灵活的路由功能&#xff0c;支持静态路由和动态路由两种模式&#xff0c;让开发者能够轻松构建各种复杂的 Web 应用。本文将详细介绍这两种路由的使用方法。 静态路由&#xff1a;简单…
阅读更多...
铰链损失函数 Hinge Loss和Keras 实现

铰链损失函数 Hinge Loss和Keras 实现

一、说明 在为了了解 Keras 深度学习框架的来龙去脉&#xff0c;本文介绍铰链损失函数&#xff0c;然后使用 Keras 实现它们以进行练习并了解它们的行为方式。在这篇博客中&#xff0c;您将首先找到两个损失函数的简要介绍&#xff0c;以确保您在我们继续实现它们之前直观地理解…
阅读更多...
瑞数信息发布《BOTS自动化威胁报告》，揭示AI时代网络安全新挑战

瑞数信息发布《BOTS自动化威胁报告》，揭示AI时代网络安全新挑战

近日&#xff0c;瑞数信息正式发布《BOTS自动化威胁报告》&#xff0c;力求通过全景式观察和安全威胁的深度分析&#xff0c;为企业在AI时代下抵御自动化攻击提供安全防护策略&#xff0c;从而降低网络安全事件带来的影响&#xff0c;进一步增强业务韧性和可持续性。 威胁一&am…
阅读更多...
FLV格式：流媒体视频的经典选择

FLV格式：流媒体视频的经典选择

FLV格式&#xff1a;流媒体视频的经典选择 FLV&#xff08;Flash Video&#xff09;格式曾经是流媒体视频的主力军&#xff0c;在互联网视频的早期时代广泛应用于视频网站和多媒体平台。凭借其高效的压缩和较小的文件体积&#xff0c;FLV成为了许多视频内容创作者和平台的首选…
阅读更多...
需求分析-用例图绘制、流程图绘制

需求分析-用例图绘制、流程图绘制

第一&#xff0c;引论 需求分析是开发的第一步&#xff0c;也是我个人认为最重要的一步。 技术难题的克服&#xff0c;甚至在我心里&#xff0c;还要排在需求分析后面。 如果需求分析做好了&#xff0c;数据库就更容易建立&#xff0c;数据库建好了&#xff0c;业务逻辑写起…
阅读更多...
Windows安装 PHP 8 和mysql9，win下使用phpcustom安装php8.4.5和mysql9

Windows安装 PHP 8 和mysql9，win下使用phpcustom安装php8.4.5和mysql9

百度搜索官网并下载phpcustom&#xff0c;然后启动环境&#xff0c;点击网站管理 里面就有php8最新版&#xff0c;可以点mysql设置切mysql9最新版&#xff0c;如果你用最新版无法使用&#xff0c;说明你的php程序不支持最新版的mysql MySQL 9.0 引入了一些新的 SQL 模式和语法变…
阅读更多...
http://noi.openjudge.cn/_2.5基本算法之搜索_1804:小游戏

http://noi.openjudge.cn/_2.5基本算法之搜索_1804:小游戏

文章目录 题目深搜代码宽搜代码深搜数据演示图总结 题目 1804:小游戏 总时间限制: 1000ms 内存限制: 65536kB 描述 一天早上&#xff0c;你起床的时候想&#xff1a;“我编程序这么牛&#xff0c;为什么不能靠这个赚点小钱呢&#xff1f;”因此你决定编写一个小游戏。 游戏在一…
阅读更多...
手写JSX实现虚拟DOM

手写JSX实现虚拟DOM

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》、《前端求职突破计划》 &#x1f35a; 蓝桥云课签约作者、…
阅读更多...
Spring Boot 中的 Bean

Spring Boot 中的 Bean

2025/4/6 向全栈工程师迈进&#xff01; 一、Bean的扫描 在之前&#xff0c;对于Bean的扫描&#xff0c;我们可以在XML文件中书写标签&#xff0c;来指定要扫描的包路径&#xff0c;如下所示,可以实通过如下标签的方式&#xff1a; <context:component-scan base-package&…
阅读更多...
ST 芯片架构全景速览：MCU、无线 SoC、BLE 模块、MPU 差异详解

ST 芯片架构全景速览：MCU、无线 SoC、BLE 模块、MPU 差异详解

在嵌入式开发中，ST 是一个非常常见的芯片厂商，其产品线覆盖了 MCU、无线芯片、BLE 模块以及运行 Linux 的 MPU 等多个领域。很多开发者初次接触 ST 时会对这些产品之间的关系感到困惑。 本文从分类视角出发，带你快速了解 ST 芯片家族的核心架构和主要用途。 🧭 ST 芯片四…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023