[cpp进阶]C++智能指针

【C++11】三大神器之——智能指针 在Cpp11新标准下学习C++三大神器之一的智能指针 阅读详情

为什么需要智能指针?

下面我们分析一段关于异常安全的代码:

#include <iostream>
using namespace std;

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

void func()
{
	// 这里可以看到如果发生除0错误抛出异常,另外下面的array没有得到释放。
	// 所以这里捕获异常后并不处理异常,异常还是交给外面处理,这里捕获了再
	// 重新抛出去。
	int* array = new int[10];
	int len, time;
	cin >> len >> time;

	try
	{
		cout << division(len, time) << endl;
	}
	catch (...)  // 拦截异常,不是要处理异常,而是要正常释放资源
	{
		cout << "delete []" << array << endl;
		delete[] array;
		throw;  // 捕获到什么对象就重新抛出什么对象
	}

	cout << "delete []" << array << endl;
	delete[] array;
}

int main()
{
	try
	{
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
		// 记录日志
	}

	return 0;
}

由于division函数可能会抛异常,所以如果直接在main函数捕捉异常,就会导致申请出来的array资源没有得到释放,就会导致内存泄漏问题。

怎么解决这个问题呢?

  1. 在Func函数中拦截异常,将array资源释放掉,再将异常重新抛出。
  2. 申请资源后将指针交给智能指针管理。

智能指针的原理及使用

上述的异常问题,可以通过智能指针来解决。

智能指针的原理

智能指针运用了RAII的思想。RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句柄、网络连接、互斥量等等)的简单技术。

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

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

智能指针的使用

设计一个智能指针SmartPtr:

  • 在构造SmartPtr时,将用户传入的资源管理起来
  • 在析构SmartPtr时,将管理的资源释放
  • 智能指针SmartPtr能像指针一样进行解引用操作
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

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

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

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

private:
	T* _ptr;
};

实验代码:

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

void func()
{
	int* ptr = new int;
	SmartPtr<int> sp(ptr); // 使用智能指针管理ptr资源
	int len, time;
	cin >> len >> time;
	
	cout << division(len, time) << endl;
}

int main()
{
	try
	{
		func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}

	return 0;
}

实验结果:

在这里插入图片描述

在func函数中,申请了ptr资源并交于SmartPtr进行管理,当出现除0错误,异常由division函数抛出,main函数捕捉时,func函数的函数栈帧销毁,SmartPtr对象也被回收,SmartPtr对象销毁之前会调用析构函数释放管理的资源,这样就避免了内存泄漏的问题。

但是这样的SmartPtr智能指针还有问题:

int main()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(sp1);
	return 0;
}

运行结果:

在这里插入图片描述

SmartPtr智能指针不能进行拷贝构造,因为这样会释放两次资源,导致程序崩溃。


C++中的智能指针

C++智能指针的发展历程

  • C++98标准中产生了第一个智能指针auto_ptr
  • C++ boost库中给出了更实用的scoped_ptr、shared_ptr和weak_ptr
  • C++11标准中引入了unique_ptr、shared_ptr和weak_ptr,这些智能指针的实现原理都是参考boost库的,unique_ptr参考的是scoped_ptr

std::auto_ptr

std::auto_ptr的使用

C++ auto_ptr智能指针文档

std::auto_ptr的实现原理是管理权的转移。

实验代码:

#include <iostream>
#include <memory>

int main()
{
	std::auto_ptr<int> ap1(new int(10));
	std::auto_ptr<int> ap2(ap1);

	return 0;
}

实验结果:

在这里插入图片描述
std::auto_ptr解决智能指针拷贝构造的问题是用管理权转移解决的,但是随之而来会带来另一个问题,管理权转移让ap1指针悬空了,如果用户对std::auto_ptr不熟悉,继续使用ap1进行一系列操作,而ap1已经悬空,这势必会导致程序的崩溃。

实验代码:

#include <iostream>
#include <memory>

int main()
{
	std::auto_ptr<int> ap1(new int(10));
	std::auto_ptr<int> ap2(ap1);
	*ap1 = 20;

	return 0;
}

实验结果:

在这里插入图片描述


std::auto_ptr的模拟实现

下面简化模拟实现了一份auto_ptr来了解它的原理:

namespace cwx
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}

		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			// 管理权的转移
			ap._ptr = nullptr;
		}

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

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

	private:
		T* _ptr;
	};
}

std::unique_ptr

std::unique_ptr的使用

std::auto_ptr管理权转移的方式,经过时间的证明,它是一个失败的设计。C++11中引入更加实用的std::unique_ptr和std::shared_ptr。

std::unique_ptr是参考了boost库中的scoped_ptr,它的原理非常简单粗暴,它解决智能指针拷贝构造的方式是直接防拷贝。

实验代码:

#include <iostream>
#include <memory>

int main()
{
	std::unique_ptr<int> up1(new int);
	std::unique_ptr<int> up2(up1);       // error

	return 0;
}

实验结果:
在这里插入图片描述


std::unique_ptr的模拟实现

下面简化模拟实现了一份unique_ptr来了解它的原理:

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

		// 防拷贝
		unique_ptr(const unique_ptr<T>&) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;

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

		T* operator->()
		{
			return _ptr;
		}
		
		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}

	private:
		T* _ptr;
	};
}

std::shared_ptr

std::shared_ptr的使用

std::unique_ptr实现了简单粗暴的防拷贝,但是难以避免要需要用到拷贝。C++11引入了std::unique_ptr,std::unique_ptr使用了引用计数的技术来实现智能指针的拷贝问题。

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

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

实验代码:

#include <iostream>
#include <memory>

int main()
{
	std::shared_ptr<int> sp1(new int(10));
	std::shared_ptr<int> sp2(sp1);

	std::shared_ptr<int> sp3(new int(20));
	sp3 = sp2;

	return 0;
}

实验结果:

在这里插入图片描述

原理:

  • std::shared_ptr<int> sp1(new int(10));定义了智能指针sp1,管理new出来的int空间,sp1对象中的引用计数加一,refs = 1
  • std::shared_ptr<int> sp2(sp1);定义了智能指针sp2,拷贝sp1,sp1和sp2对象中的引用计数加一,refs = 2
  • std::shared_ptr<int> sp3(new int(20));定义了智能指针sp3,管理new出来的int空间,sp3对象中的引用计数加一,refs = 1
  • sp3 = sp2;,sp3对象赋值拷贝sp2,原来sp3指向的空间的引用计数减一,refs = 0,则释放值为20的空间,sp3现在指向值为10的空间,sp1、sp2和sp3的引用计数加一,refs = 3
    在这里插入图片描述

std::shared_ptr的模拟实现

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

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

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

			return *this;
		}

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

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

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

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

std::shared_ptr的线程安全问题

模拟实现的shared_ptr还存在线程安全的问题,由于管理同一个资源的多个对象的引用计数是共享的。

在多线程环境下可能会同时对同一个引用计数进行自增或自减操作,而自增和自减操作都不是原子操作,因此需要通过加锁来对引用计数进行保护,否
则就会导致线程安全问题。

加锁后代码:

  • 将进行引用计数自增自减的代码封装成函数,便于加锁
  • 引入mutex,对自增自减操作进行加锁
namespace cwx
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pRefCount(new int(1))
			, _pmtx(new mutex)
		{}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmtx(sp._pmtx)
		{
			AddRef();
		}

		void AddRef()
		{
			_pmtx->lock();

			++(*_pRefCount);

			_pmtx->unlock();
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();

				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				AddRef();
			}

			return *this;
		}

		void Release()
		{
			_pmtx->lock();

			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}

			_pmtx->unlock();
			if (flag)
			{
				delete _pmtx;
			}
		}

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

		T* operator->()
		{
			return _ptr;
		}
		
		T* get() const
		{
			return _ptr;
		}
		
		~shared_ptr()
		{
			Release();
		}

	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};
}

std::weak_ptr

std::shared_ptr的循环引用

实验代码:

struct ListNode
{
	int _val;
	cwx::shared_ptr<ListNode> _prev;
	cwx::shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};

int main()
{
	cwx::shared_ptr<ListNode> node1(new ListNode);
	cwx::shared_ptr<ListNode> node2(new ListNode);

	node1->_next = node2;
	node2->_prev = node1;

	return 0;
}

实验结果:

在这里插入图片描述

实验原理

程序创建了node1和node2两个链表结点,用shared_ptr智能指针管理,node1和node2的引用计数当前分别为1,node1的_next指向node2,node2的_prev指向node1,此时node1和node2的引用计数分别为2。

在这里插入图片描述

程序运行结束后,node1和node2调用析构函数,引用计数减一,此时引用计数为1,然而程序已经结束,node1和node2开辟的空间并没有被释放,这种现象叫做循环引用。


std::weak_ptr的使用

在上述的实验场景中,循环引用导致资源没有被释放的问题,需要使用std::weak_ptr来解决。

std::weak_ptr的原理是可以获取并访问指向的资源,但是不参与引用计数。

实验代码:

struct ListNode
{
	int _val;
	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);

	node1->_next = node2;
	node2->_prev = node1;

	return 0;
}

实验结果:

在这里插入图片描述


std::weak_ptr的模拟实现

下面简化模拟实现了一份weak_ptr来了解它的原理:

namespace cwx
{
	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;
	};
}

智能指针的定制删除器

模拟实现的智能指针默认都用delete释放资源,但是如果是申请一个数组资源,fopen打开一个文件,delete就会不匹配或者程序直接就崩溃了。

C++文档中,智能指针的接口定义了一个模板D,就是定制删除器。定制删除器本质是一个可调用对象,比如函数指针、仿函数或者lambda表达式。

在这里插入图片描述

下面给unique_ptr实现一个简化的定制删除器:

namespace cwx
{
	template<class T, class D = default_delete<T>>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}

		// 防拷贝
		unique_ptr(const unique_ptr<T>&) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;

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

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

		~unique_ptr()
		{
			if (_ptr)
			{
				D del;
				del(_ptr);
			}
		}

	private:
		T* _ptr;
	};
}

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

template<class T>
struct DelFile
{
	void operator()(FILE* file_name)
	{
		cout << "fclose: " << file_name << endl;
		fclose(file_name);
	}
};

int main()
{
	unique_ptr<int, DelArray<int>> up1(new int[10]);
	unique_ptr<FILE, DelFile<FILE>> up2(fopen("test.txt", "w"));

	return 0;
}

CPP 智能指针总结分享 CPP 智能指针 shared_ptr、unique_ptr、weak_ptr 总结梳理分享 阅读详情

相关推荐

C++经典面试题之深入解析智能指针unique_ptr的实现原理与自定义实现

unique_ptr 独享它指向的对象,也就是说,同时只有一个 unique_ptr 指向同一个对象,当这个 unique_ptr 被销毁时,指向的对象也随即被销毁。这也是它和 shared_pt r不一样的地方,它不需要做引用计数,也不可以被第二个人引用,只有它自己。unique_ptr 作为一个类的成员变量,这个变量只在本类使用,不会被赋值给其他类,也不会作为参数传递给某个函数;在一个函数作为局部变量,使用完就不用再管,函数结束,自动释放托管资源。

╰つ栺尖篴夢ゞ 2143

【cpp--->智能指针】

智能指针有些场景会造成循环引用的,循环引用,就是两个智能指针相互依赖,释放时互相制约,形成引用死循环,资源无法被释放,造成内存泄漏.以链表节点的链接为例,两个节点相连,节点1的next链接节点2,节点2的pre链接节点1,这两个节点的指针以及节点内部的指针都用希尔智能指针,这时节点1和节点2的引用计数都是2,出作用域时,节点2引用计数-1,节点1的引用计数-1,但是这两个节点都无法释放,因为。智能指针解决了资源释放的问题,但是还要有原生指针的使用方法和功能,这就需要解决指针的解引用,拷贝和赋值问题。

kk1125778230的博客 865

AI计算,为什么要用GPU?

几年后,2012年,神经网络之父杰弗里·辛顿(Geoffrey Hinton)的两个学生——亚历克斯·克里切夫斯基(Alex Krizhevsky)、伊利亚·苏茨克沃(Ilya Sutskever),利用“深度学习+GPU”的方案,提出了深度神经网络AlexNet,将识别成功率从74%提升到85%,一举赢得Image Net挑战赛的冠军。根据形态,GPU可分为独立GPU(dGPU,discrete/dedicated GPU)和集成GPU(iGPU,integrated GPU),也就是常说的独显、集显。

经营范围: CTA、SRRC、CCC、移动、电信、联通入库 1679

[cpp] 智能指针

cpp--智能指针详解

BinaryWiker的博客 1224

PX4无人机-Gazebo仿真实现动态目标追踪的视觉控制方案

本文详细介绍了PX4无人机在Gazebo仿真环境中实现动态目标追踪的视觉控制方案。从PX4与Gazebo仿真环境搭建、动态目标追踪核心技术栈、仿真环境深度定制技巧到追踪算法的优化实践,提供了全面的技术指导和常见问题排查方法,帮助开发者高效实现无人机视觉追踪功能。

weixin_29196315的博客 456

牛耕式全覆盖算法-matlab代码

牛耕式路径全覆盖算法,也称为牛耕算法或者蚂蚁算法,是一种用于解决路径规划问题的启发式算法。这个算法的灵感来自于牛在耕田时的行为。在这个算法中,假设有一块田地需要耕作,牛从田地的某个角落开始行走,走过的路径会被标记。牛会优先选择尚未经过的路径,当所有的路径都走过后,算法停止。在路径规划问题中,田地可以看作是一个由节点和边构成的图。每个节点代表一个位置,每条边代表两个节点之间的连接。路径全覆盖问题是找出一组路径,使得每个节点都被至少一条路径经过。牛耕式路径全覆盖算法的基本思想是以启发式的方式逐步构建路径。

m0_69611489的博客 1692

C++11:智能指针

全局对象:程序启动时分配,在程序结束时销毁。局部对象:当我们进入其定义所在的程序块时被创建,在离开块时销毁。局部static对象:在第一次使用前分配,在程序结束时销毁。静态内存:保存局部static对象、类static数据成员以及定义在任何函数之外的变量。栈内存:保存定义在函数内的非static对象。分配在静态或栈内存中的对象由编译器自动创建和销毁。对于栈对象,仅在其定义的程序块运行时才存在;static对象在使用之前分配,在程序结束时销毁。除了静态内存和栈内存,每个程序还拥有一个内存池。

Man9o 1818

UMD与KMD的协同交响曲:揭秘图形渲染背后的驱动架构设计

本文深入解析了图形渲染中用户态驱动(UMD)与内核态驱动(KMD)的协同架构设计,揭秘了从API调用到像素渲染的完整流水线。通过分析UMD的API转换、着色器编译等核心职责,以及KMD的内存管理、任务调度等关键功能,帮助开发者优化图形应用性能,提升渲染效率。

cc789的博客 739

Ritual进阶技巧:处理C++复杂类型与内存安全的实战经验

Ritual作为一款强大的工具,能帮助开发者在Rust中高效使用C++库,尤其在处理C++复杂类型和保障内存安全方面展现出独特优势。本文将分享一系列实用的进阶技巧,助力开发者更好地应对C++复杂类型与内存安全挑战。 ## 理解C++复杂类型在Rust中的表示 在Rust中使用C++库时,首先要理解C++复杂类型在Rust中的表示方式。C++的类、结构体等复杂类型在Rust中通常需要通过特定的绑

gitblog_00771的博客 1062

coze开发-5、给智能体添加“技能”

中间编排与技能组件 中间编排的定义 中间编排是指在智能体的构建过程中,使用一些工具对智能体进行协调和管理。通过这些工具,我们能够更好地实现智能体在特定业务场景中的应用。

andyyah晓波的博客 529

【23】OpenCV C++实战篇——张正友相机标定【相机标定原理、相机标定流程、标定结果评价、图像畸变矫正】

R是3×3的正交单位矩阵(即旋转矩阵),t为平移向量,R、t与摄像机无关,所以称这两个参数为摄像机的外参数(extrinsicparameter),可以理解为两个坐标原点之间的距离,因其受x,y,z三个方向上的分量共同控制,所以其具有三个自由度。R是3×3的正交单位矩阵(即旋转矩阵),t为平移向量,R、t与摄像机无关,所以称这两个参数为摄像机的外参数(extrinsicparameter),可以理解为两个坐标原点之间的距离,因其受x,y,z三个方向上的分量共同控制,所以其具有三个自由度。

程序员,他们想的是什么?他们想的永远都是技术,他们崇尚的也永远都是技术。 4484

如何快速掌握Godot-CPP:解锁C++高性能游戏开发终极方案

你是否曾因GDScript的性能瓶颈而苦恼?是否渴望在Godot中实现更复杂的游戏逻辑?今天,让我们一起探索Godot-CPP——这个为Godot引擎量身定制的C++绑定库,它将彻底改变你的游戏开发体验!🚀 ## 核心理念解析:C++与Godot的完美融合 Godot-CPP的核心设计理念是**无缝桥接**——在保持Godot编辑器友好性的同时,让你能够充分利用C++的性能优势。这个库不是简

gitblog_00152的博客 102

Unity 热更新技术 |(六)xLua框架学习最新系列完整教程

开始学习热更新方面系列知识,就从这一篇开始吧! 本系列教程 会从热更新基本概念出发,详细介绍热更新相关的全套知识点。 如热更新技术基本原理、热更新主流方案、AssetBundle系列教程、Lua语言编程、Lua与Unity交互教程、Xlua框架使用、热更新实战教程等方面。 热更新作为一个开发者必备技能,如果想学习的话,可以从现在开始了哦~ 接下来先从XLua学习使用 开始学习吧!

努力前行,总会成为自己心中的那道光 1万+

Cpp 进阶:Smart Pointer 智能指针

Cpp 进阶:Smart Pointer 智能指针 文章目录Cpp 进阶:Smart Pointer 智能指针简介参考正文核心目的功能需求C++ 实现智能指针(包装类)全局工厂包装函数测试用对象类测试代码结语 简介 我们都知道 Java 和 C++ 一样,运行时会同时维护一个堆(Heap)空间与栈(Stack)空间。通常局部变量、函数参数等都会存放在栈空间,跟着函数运行周期一起消亡;而 Java 和 C++ 对于堆空间的控制则不太相同: 对于 Java **“万物皆对象”**的设计理念,程序以对象(Ob

超悠閒的博客 514

51单片机 DHT11温湿度传感器LCD显示+串口打印+Proteus仿真

DHT11+LCD1602+串口输出+Proteus仿真

perseverance51博客 7205

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

[C++] 智能指针 进阶

[C++] 智能指针 进阶 在很久之前我们探讨了智能指针的浅显认识,接下来会更加深入,从源码角度认识智能指针,从而了解智能指针的设计原理,并应用到以后的工作项目中。本文将会按照C++智能指针的发展历史,回顾智能指针的各个版本的设计。后半部分将会模拟实现最常考的shared_ptr的功能。

石墨博客 1258

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

C++进阶——C++11_智能指针

什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存,一般是忘记释放或者发生异常释放程序未能执行导致的。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存的浪费。内存泄漏的危害普通程序运行一会就结束了出现内存泄漏问题也不大,进程正常结束,页表的映射关系解除,物理内存也可以释放。长期运行的程序出现内存泄漏影响很大。

博客 | 复习知识点 + 练习 + 最终的领悟 | 全力以赴 1526

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

C++进阶--C++11智能指针

智能指针不是指针,是一个管理指针的类,用来存储指向动态分配对象的指针,负责自动释放动态分配的对象,防止堆内存泄漏。动态分配的资源,交给一个类对象去管理,当类对象生命周期结束时,自动调用析构函数释放资源。RAII是resource acquisition is initialization的缩写,意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念,其核心是把资源和对象的生命周期绑定,对象创建获取资源,对象销毁释放资源。

sushang的博客 6199

C++学习进阶:C++11|智能指针

这是一篇又臭又长又精华的博客,需要每一个模块认真学习,仔细理解,这一部分也是C++面试常考的内容,那么废话不多说,just do it!

weixin_73234157的博客 1273

《C++进阶之C++11》【智能指针】(上)

本文介绍了C++中三种常用智能指针:unique_ptr、shared_ptr和weak_ptr。文章通过代码示例演示了各类智能指针的基本用法和适用场景,并强调其基于RAII机制自动管理内存的核心优势。

序属秋秋秋的博客 1332

【C++进阶】智能指针的使用及其原理

本文介绍了C++智能指针的使用场景、设计思路及标准库实现。主要内容包括: 通过异常处理案例展示内存泄漏问题,说明智能指针的必要性; 提出RAII(资源获取即初始化)设计思想,利用对象生命周期管理资源; 设计简易智能指针类,实现资源自动释放和指针行为模拟; 分析智能指针拷贝问题,对比标准库的auto_ptr、unique_ptr等解决方案; 重点指出auto_ptr存在管理权转移缺陷,建议避免使用。 文章通过代码示例和图示,系统讲解了智能指针如何解决资源泄漏问题,并比较了不同智能指针的实现特点。

Linux、C++、图形软件开发等。不一定每次都能写出完美的代码,但会认真搞懂每一个问题。 7377

《C++进阶之C++11》【智能指针】(下)

本文是C++智能指针系列的下篇,重点剖析auto_ptr和unique_ptr、shared_ptr、weak_ptr的原理与实现。作为作者C++系列的完结篇,本文延续了通俗易懂的讲解风格,通过代码注释和对比分析帮助读者理解智能指针的核心机制,为后续学习现代C++内存管理奠定基础。

序属秋秋秋的博客 1582

C++进阶-智能指针

什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存的浪费。内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行,p3没被释放.

weixin_64423718的博客 1081

C++进阶:智能指针

其除了具备智能指针管理资源与指针操作的功能外,对智能指针的拷贝也做了相关的实现,其设计思路为拷贝后,将指针转移,将原有指针悬空。weak_ptr只做链接功能,因为weak_ptr与shared_ptr不是一个类型的智能指针,weak_ptr想要从shared_ptr获取资源只有两个方式,一是被声明为友元,二是为shared_ptr添加get接口,get接口必须使用const修饰this指针。自定义一个双向链表的节点,链表的每个节点都是动态开辟而出的,这里我们采用智能指针的方式去定义与管理。

qq_71806743的博客 1335

C++进阶——智能指针(C++11)

所以,总的来说,如果我们要用智能指针的话,一般用 shared_ptr 和 weak_ptr 搭配用就可以解决程序因为抛异常而导致执行流乱跳,进而造成内存泄漏等问题了。

m0_73093743的博客 1990

【C++进阶学习】第十三弹——C++智能指针的深入解析

【C++进阶学习】:C++掌握内存管理重要一步——智能指针的深入解析:什么是智能指针?为什么需要智能指针?一篇带你搞清楚智能指针的作用及原理

2301_80220607的博客 3312
上一篇: [Linux]多线程的同步和互斥(线程池 | 单例模式 | 其他常见的锁 | 读者写者问题)
下一篇: [cpp进阶]C++异常
还小给个面子
博客等级 码龄6年 788粉丝 53原创
评论 21
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

还小给个面子

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址