探索智能指针

最新推荐文章于 2024-06-29 18:31:57 发布
最新推荐文章于 2024-06-29 18:31:57 发布
阅读量260 收藏 3
点赞数
分类专栏： C++ 文章标签： 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ych9527/article/details/118014687
版权

文章目录

1.为什么需要智能指针

程序员自己控制的内存，在一些特殊场景之下，有可能发生内存泄漏，智能指针则可以帮助对内存进行管理
比如程序员忘记释放内存，异常的出现，可能会导致内存泄漏

智能指针采用的RAII思想 -> 利用对象的生命周期来控制程序资源，在对象构建的时候获取资源，在对象析构的时候释放资源，即将对资源的管理工作，托付给了一个对象，这样做的好处是：不需要显示的释放资源、对象所需要的资源，在其生命周期内始终保持有效

template<class T>
class smartPtr
{
public:
	
	smartPtr(T *ptr)
		:_Ptr(ptr)
	{}

	~smartPtr()
	{
		cout << "~smartPtr()" << endl;
		delete[] _Ptr;
	}

private:
	T *_Ptr;
};

void test()
{
	while (1)
	{
		int *ptr = new int;

		//使用ARII思想，管理资源，如果没有，当抛异常的时候，并不会释放资源
		//就会导致内存泄漏
		smartPtr<int> sptr(ptr);
		throw 1;

		//delete ptr;
	}
}

void Ptrtest()
{
	while (1)
	{
		try
		{
			test();
		}

		catch (...)
		{
			cout << "catch (...) " << endl;
		}
	}
}

2.三种智能指针使用及原理分析

2.1 auto_ptr

1.使用立即初始化，防止二次释放

在这里插入图片描述

2.拷贝和赋值会导致资源管理权转移，再次解引用就会造成空指针的访问

在这里插入图片描述
3.由于auto_ptr 的拷贝和赋值拷贝都会出现资源转移的情况，即使用的时候很容易出错，因此实际之中，一般不允许使用

4.模拟实现

template<class T>
class Auto_ptr
{
public:

	Auto_ptr(T *ptr)
		:_ptr(ptr)
	{}

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

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

	Auto_ptr<T>& operator =(Auto_ptr<T>& ap)
	{
		if (this != &ap)
		{
			//释放资源
			if (_ptr)
				delete _ptr;
			
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}

		return *this;
	}

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

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

private:
	T *_ptr;
};



class Data
{
public:
	Data(int day)
		:_day(day)
	{}

	int _day;
};

2.2 unique_ptr

既然auto_ptr的拷贝和赋值会发生资源转移，那么unique_ptr，就禁止拷贝和赋值的发生，即在拷贝和赋值成员函数后面加上delete
在这里插入图片描述

模拟实现:

template<class T>
class Unique_ptr
{
public:

	Unique_ptr(T *ptr)
		:_ptr(ptr)
	{}

	~Unique_ptr()
	{
		delete[] _ptr;
	}

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

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

	//禁止拷贝和赋值
	Unique_ptr(Unique_ptr<T>& up)=delete;
	Unique_ptr<T>& operator =(Unique_ptr<T>& up)=delete;

private:
	T *_ptr;
};

2.3shared_ptr

2.3.1原理

auto_ptr 的拷贝和赋值存在不安全因素，unnique_ptr直接禁止了拷贝和赋值

如果智能指针需要拷贝和赋值呢，这时候，就得看shared_ptr了
在这里插入图片描述

如何实现:
我们可以给定一个资源计数器，当前资源被多少个智能指针管理，计数器则为几，当进行析构的时候，计数器–，当计数器为0的时候，表示当前资源没有被管理了，则对该资源进行delete

template<class T>
class Shared_ptr
{
public:

	Shared_ptr(T *ptr)
		:_ptr(ptr)
		, _CountPtr(new int(1))//构造的时候，被一个管理起来
	{}

	~Shared_ptr()
	{
		(*_CountPtr)--;

		if (*_CountPtr == 0)//为0时，表示没有管理的了
		{
			delete _ptr;
			delete _CountPtr;
		}
	}

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

	Shared_ptr<T> &operator=(const Shared_ptr<T> &sp)
	{
		//判断是不是管理的同一份资源
		if (_ptr != sp._ptr)
		{
			if (--(*_CountPtr) == 0)//断开已经管理的资源
			{
				delete _ptr;//如果管理的资源没有其它人进行管理了，则释放掉
				delete _CountPtr;
			}

			//赋值
			_ptr = sp._ptr;
			_CountPtr = sp._CountPtr;
			(*_CountPtr)++;
		}

		return *this;
	}

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

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

	int GetCount()
	{
		return *_CountPtr;
	}

private:
	T *_ptr;
	int *_CountPtr;//通过指针，来控制管理同一份资源的，都指向同一块地址空间
};

2.3.2线程安全问题

多线程之中，在进行拷贝和赋值的时候，线程计数器就变成了临界资源，这时候，就需要对线程计数器进行加锁处理，否则会发生线程安全问题

class Data
{
public:
	Data(int day)
		:_day(day)
	{}

	int _day;
};

void func(Shared_ptr<Data> &sp,int n)
{

	for (int i = 0; i < n; i++)
	{
		Shared_ptr<Data> sp2(sp);//进行n次拷贝
	}
}


void test()
{
	Shared_ptr<Data> sp(new Data(1000));
	cout << "begin:" << sp.GetCount() << endl;

	int n;
	cin >> n;


	thread t1(func, ref(sp), n);//使用ref线程函数的参数是以值拷贝的方式到线程栈空间的
	thread t2(func, ref(sp), n);

	t1.join();
	t2.join();

	cout << "end:" << sp.GetCount() << endl;
}

在这里插入图片描述

加锁后的代码和实验效果:

template<class T>
class Shared_ptr
{
public:

	Shared_ptr(T *ptr)
		:_ptr(ptr)
		, _CountPtr(new int(1))//构造的时候，被一个管理起来
		, _mtx(new mutex)//初始化一把锁
	{}

	~Shared_ptr()
	{
		subRef();//加锁后的--操作
		//(*_CountPtr)--;

		if (*_CountPtr == 0)//为0时，表示没有管理的了
		{
			delete _ptr;
			delete _CountPtr;
			delete _mtx;
			cout << "~Shared_ptr()" << endl;
		}
	}

	Shared_ptr(const Shared_ptr<T> &sp)
		:_ptr(sp._ptr)
		, _CountPtr(sp._CountPtr)
		, _mtx(sp._mtx)
	{
		addRef();//加锁后的++操作
		//(*_CountPtr)++;
	}

	Shared_ptr<T> &operator=(const Shared_ptr<T> &sp)
	{
		//判断是不是管理的同一份资源
		if (_ptr != sp._ptr)
		{
			//if (--(*_CountPtr) == 0)//断开已经管理的资源
			if (subRef==0)
			{
				delete _ptr;//如果管理的资源没有其它人进行管理了，则释放掉
				delete _CountPtr;
				delete _mtx;
			}

			//赋值
			_ptr = sp._ptr;
			_CountPtr = sp._CountPtr;
			_mtx = sp._mtx;
			addRef();
		}

		return *this;
	}

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

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

	int GetCount()
	{
		return *_CountPtr;
	}

	int addRef()
	{
		_mtx->lock();
		(*_CountPtr)++;
		_mtx->unlock();

		return *_CountPtr;
	}

	int subRef()
	{
		_mtx->lock();
		(*_CountPtr)--;
		_mtx->unlock();

		return *_CountPtr;
	}

private:
	T *_ptr;
	int *_CountPtr;//通过指针，来控制管理同一份资源的，都指向同一块地址空间
	mutex *_mtx;//加上一把锁
};

在这里插入图片描述

2.3.3循环引用问题

template <class T>
struct ListNode
{
	shared_ptr<ListNode<T>> _next;
	shared_ptr<ListNode<T>> _prev;

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

void test()
{
	shared_ptr<ListNode<int>> sp(new ListNode<int>);
	shared_ptr<ListNode<int>> sp2(new ListNode<int>);
	
	cout << "begin:" << sp.use_count() << " " << sp2.use_count() << endl;
	sp->_next = sp2;
	sp2->_prev = sp;
	cout << "end:" << sp.use_count() << " " << sp2.use_count() << endl;
}

在这里插入图片描述

解决办法:

使next和prev管理资源的时候，计数器不会增加，这样就不会出现内存泄漏的问题了
于是有了weak_ptr智能指针，不会增加计数器

	template <class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:ptr=nullptr
		{}


		weak_ptr(const shared_ptr<T> &p)
			:ptr(p.ptr)
		{}

		weak_ptr<T>& operator =(const shared_ptr<T> &p)
		{
			if (*this!=p)
				ptr = p.ptr;
			return *this;
		}

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

		T* operator()
		{
			return ptr;
		}

	private:
		T *ptr;
	};
}

emplate <class T>
struct ListNode
{
	weak_ptr<ListNode<T>> _next;//使用weak_ptr，不会增加计数器的值
	weak_ptr<ListNode<T>> _prev;

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

在这里插入图片描述

2.3.4删除问题

shared_ptr 析构函数中资源的释放，默认是使用delete的，如果我们的对象时malloc出来的，或者是new出来的一整块空间，该怎么办呢？
shared_ptr之中提供了一个删除器(仿函数)，可以通过自己传入的仿函数进行资源的释放

template<class T,class Del>
class Shared_ptr
{
public:

	Shared_ptr(T *ptr,Del del)
		:_ptr(ptr)
		, _CountPtr(new int(1))//构造的时候，被一个管理起来
		, _mtx(new mutex)//初始化一把锁
		, _del(del)
	{}

	~Shared_ptr()
	{
		subRef();//加锁后的--操作
		//(*_CountPtr)--;

		if (*_CountPtr == 0)//为0时，表示没有管理的了
		{
			//delete _ptr;
			_del(_ptr);//使用删除器来释放资源
			delete _CountPtr;
			delete _mtx;
			cout << "~Shared_ptr()" << endl;
		}
	}

	Shared_ptr(const Shared_ptr<T,Del> &sp)
		:_ptr(sp._ptr)
		, _CountPtr(sp._CountPtr)
		, _mtx(sp._mtx)
	{
		addRef();//加锁后的++操作
		//(*_CountPtr)++;
	}

	Shared_ptr<T, Del> &operator=(const Shared_ptr<T, Del> &sp)
	{
		//判断是不是管理的同一份资源
		if (_ptr != sp._ptr)
		{
			//if (--(*_CountPtr) == 0)//断开已经管理的资源
			if (subRef==0)
			{
				del(ptr);//使用删除器来释放资源
				//delete _ptr;//如果管理的资源没有其它人进行管理了，则释放掉
				delete _CountPtr;
				delete _mtx;
			}

			//赋值
			_ptr = sp._ptr;
			_CountPtr = sp._CountPtr;
			_mtx = sp._mtx;
			addRef();
		}

		return *this;
	}

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

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

	int GetCount()
	{
		return *_CountPtr;
	}

	int addRef()
	{
		_mtx->lock();
		(*_CountPtr)++;
		_mtx->unlock();

		return *_CountPtr;
	}

	int subRef()
	{
		_mtx->lock();
		(*_CountPtr)--;
		_mtx->unlock();

		return *_CountPtr;
	}

private:
	T *_ptr;
	int *_CountPtr;//通过指针，来控制管理同一份资源的，都指向同一块地址空间
	mutex *_mtx;//加上一把锁
	Del _del;//删除其
};



class A
{
public:
	A()
	{}

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

template<class T>//定制删除器
struct Del
{
	void operator()(T* a)
	{
		delete[] a;
	}

};
void test()
{
	Del<A> del;
	Shared_ptr<A,Del<A>> sp(new A[10],del);
}

在这里插入图片描述

3.总结

智能指针的实现：RAII思想，函数重载模拟指针功能

1.auto_ptr:
发生拷贝或者赋值时，管理权转移
潜在问题：发生拷贝之后，不能继续访问资源，会有解引用问题
一般禁止使用

2.unique_ptr：
防拷贝、防赋值
可以使用:不涉及智能指针拷贝和赋值问题

3.shared_ptr:
通过引用计数，解决拷贝问题
拷贝式，引用计数自增
析构时，引用计数自减，自减之后，如果引用计数器为0，则释放资源
特殊场景之下，会发生循环引用问题，通过weak_ptr解决
shared_ptr自身是线程安全的，但是管理的资源需要用户自己保证线程安全
shared_ptr 默认通过delete释放资源，也可以用户传入仿函数进行删除

ych9527
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
unique_ptr一个会转移数据的智能指针
zhghost的专栏
11-24 1350
一、产生的原因：unique_ptr的产生，就是为了解决，raw pointer 的new和delete配对使用问题。对于raw pointer来说，在new了之后，在delete之前往...
MyMiniLib:一些基本功能的实现，例如C ++中的智能指针
04-30
《MyMiniLib：深入探索C++智能指针的实现与应用》 MyMiniLib是一个开源项目，旨在实现一些基础但至关重要的编程功能，特别关注C++中的智能指针。智能指针是C++中用于自动管理内存的重要工具，它极大地简化了内存...
unique_ptr的日常使用
did_you的博客
04-08 1495
一、对于new一个字符数组，可以在其返回指针的时候析构。 unique_ptr的第一个参数为指针数据类型，第二个参数为该指针自定义的析构器，function指示回调函数（即析构函数），然后在指针初始化时指定具体的析构函数，下面的例子中直接使用lambda表达式作为析构函数。 std::unique_ptr<char, std::function<void(char *)>&...
C++主动释放unique_ptr
爱就是是恒久忍耐的专栏
01-10 7187
主动释放unique_ptr
C++智能指针unique_ptr 详解
sinat_31608641的博客
07-29 8668
一、智能指针 C++智能指针是包含重载运算符的类，其行为像常规指针，但智能指针能够及时、妥善地销毁动态分配的数据，并实现了明确的对象生命周期，因此更有价值。 二、unique_ptr 简介 unique_ptr 是从 C++ 11 开始，定义在 <memory> 中的智能指针(smart pointer)。它持有对对象的独有权，即两个 unique_ptr 不能指向一个对象，不能进行复制操作只能进行移动操作。 unique_ptr 之所以叫这个名字，是因为它智能指向一个对象，即当它指向其
C++——探索智能指针的设计原理
最新发布
strive_mianyang的博客
06-29 3577
C++智能指针篇， 供自己复习的笔记以及分享知识点。
探索智能指针的新境界：CactusRef
gitblog_00013的博客
06-15 496
探索智能指针的新境界：CactusRef cactusref???? Cycle-Aware Reference Counting in Rust项目地址:https://gitcode.com/gh_mirrors/ca/cactusref 在现代软件开发中，内存管理是每个开发者不可忽视的核心技能之一。特别是在Rust这样强类型、系统级编程语言中，内存管理尤为重要。今天，我们来揭开一个激动人心的开源...
C++探索智能指针
FF_YTA911的博客
12-09 130
一、 RAII（Resource Acquisition Is  Initialization） 资源分配即初始化，定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。 RAII是一种思想，智能指针是RAII思想的一种应用。 小知识：别的语言都有gc垃圾回收，即在堆上创建的内存，在不用这个对象时，会自动回收这些空间，使...
C++ 智能指针 — 探索智能指针变量在类中销毁的顺序（学习笔记二）
acdfg123的博客
06-26 1108
各位路过的大神，要看懂我这篇文章，需要看一下我的第一章笔记： https://blog.csdn.net/acdfg123/article/details/118226287?spm=1001.2014.3001.5502 我这一章是基于前一章的序章，后续的笔记都是由第一章的最基础工程来进行实验 1.创建新类 TestB（直接复制TestA的内容），内容如下： class TestB { public: TestB(const std::string inName) :_name...
智能指针——浅析
分享学习过程中的知识和感悟
01-31 743
在异常产生进行跳转时，通过栈帧回收进行内存释放，防止内存泄漏基于RAII思想可以创建出只能指针RAII(Resource Acquisition Is Initialization)——是一种利用对象控制空间生命周期的技术这种技术好处就在于可以自动化的释放资源智能指针——使用如指针，支持->和**针对内置数据类型->针对自定义数据类型先介绍一个对象管理一份资源。
智能指针的标准之争+再论智能指针的标准之争
08-15
总的来说，智能指针的标准之争反映了C++社区对内存管理最佳实践的持续探索。无论是选择标准库的实现还是依赖第三方库，开发者都应根据项目需求和性能要求来决定最适合的智能指针类型。理解各种智能指针的特性和应用...
cpp经典优化方案示例c++源码(涵盖对象优化、重载、继承、多态、线程、智能指针、函数对象等17种优化方案）.zip
05-31
cpp经典优化方案示例c++源码(涵盖对象优化、重载、继承、多态、线程、智能指针、函数对象等17种优化方案）.zipcpp经典优化方案示例c++源码(涵盖对象优化、重载、继承、多态、线程、智能指针、函数对象等17种优化方案...
探索Boost中的智能指针：如何避免内存泄漏
# 第一章：智能指针概述 ## 1.1 什么是智能指针 智能指针是一种用于自动管理内存生命周期的指针类，它能够在对象不再需要时自动释放所指向的内存空间，从而避免内存泄漏和空悬指针等问题。智能指针通常会在对象...
类和对象——登堂入室
ych9527的博客
03-06 3833
文章目录1.构造函数之初始化列表1.1构造函数体赋值1.2初始化列表1.2.1是什么是初始化列表1.2.2需要注意的几点 1.构造函数之初始化列表 1.1构造函数体赋值 在创建对象时，编译器会通过调用构造函数，给对象中各个成员变量一个合适的初始值，如下图代码所示： 如上图所示，尽管构造函数被调用后，对象中已经有了一个初始值，但是这不能称为类对象成员的初始化。因为调用构造函数的时候就已经进行了对象成员的定义，构造函数体内的语句只能将其称之为赋初值。且初始化只能初始化一次，而构造函数体内可以多次赋值 1.2
了解STL、初识string
ych9527的博客
03-20 2059
文章目录1.STL1.1 什么是STL1.2 STL六大基本组件1.3为什么要学习STL1.4STL的缺陷2.什么是string类2.1为什么学习2.2了解string类3.string成员函数3.1 string构造函数3.2string类对象容器(数据结构)操作4.string类对象的访问和遍历 1.STL 1.1 什么是STL STL是C++标准库的重要组成部分，不仅仅是一个可复用的组件库，还包罗数据结构与算法的软件框架； STL的原始版本出自惠普实验室，并且进行了开源，允许任何人进行任何操作，唯一条
vector常用接口
ych9527的博客
04-01 1688
文章目录1.vector介绍2.构造函数2.1默认构造函数2.2半缺省构造2.3拷贝构造2.4迭代器构造3.元素访问方式3.1[下标]访问、迭代器访问3.2范围for需注意陷阱4.容器接口4.1max_size(无用接口)4.2size、capacity、reserve、resize4.2.1使用展示4.2.2capacity增容规则4.3[]访问4.4swap4.5push_back、pop_back4.6insert、erase4.7迭代器失效4.8find 1.vector介绍 1.是表示大小可以改变
动态内存管理
ych9527的博客
03-12 1051
文章目录1.C++中为什么要更新动态内存的管理方式2.new/delete用法 1.C++中为什么要更新动态内存的管理方式 C语言管理内存的方式在C++中还是可以用的，绝大部分语言是具有包容性的。C++中提出了自己的内存管理方式：通过new和delete操作符进行内存管理； 既然C语言中的内存管理方式可以用，为什么C++要有新的方法呢？ 这是因为针对内置类型C和C++的管理方式没有区别，针对自定义类型的时候，malloc和free只管开空间和调用析构函数。new和delete会进行开空间，调构造函数，调析构
哈希表底层探索
ych9527的博客
06-12 1036
文章目录1.unordered_ map、unordered_set1.1介绍1.2效率对比1.3实战演练2.哈希2.1哈希的概念2.2哈希函数2.2.1设计原则2.2.2常见哈希函数2.2.2.1常用哈希函数2.2.2.2 不常用哈希函数2.3哈希冲突3.闭散列3.1线性探测3.2闭散列扩容-载荷因子3.3二次探测3.4平均查找长度3.5模拟实现4.开散列4.1开散列概念4.2开散列扩容4.3总结(开散列和闭散列的比较)4.4代码实现以及效果验证 1.unordered_ map、unordered_se
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值