C++智能指针

已于 2024-04-26 23:29:24 修改
阅读量1k 收藏 30
点赞数 30
分类专栏： # C“嘎嘎” 系统学习 文章标签： c++ C++11
于 2024-04-25 16:00:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74276498/article/details/138175229
版权

智能指针

1. 异常导致的内存泄露

在我们异常那块章节中，我们有提到如果异常发生在malloc/new和free/delete之间的时候，会导致内存泄露。而我们解决办法也是非常的挫的。所以本章节就是用来解决内存泄漏问题的。

在提之前我们来复习一下什么是内存泄漏，以及他带来的危害

  • 什么是内存泄漏 ：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
  • 内存泄漏的危害 ：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

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

  • 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。
  5. 总结一下:
    内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

而本章节要将的就是用只能指针来解决内存泄露问题。

2. 智能指针的使用及原理

2.1 RAII

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

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

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

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

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}


void Func()
{
	SmartPtr<int> p1(new int(1));
	SmartPtr<int> p2(new int(2));

	cout << div() << endl;
}

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

在这里插入图片描述

  • 上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。
T& operator* ()
{
	return *_ptr;
}
T* operator->()
{
	return _ptr;
}

虽然上面的只能指针解决了内存泄漏的问题，但是同样也带来了新的问题。就是拷贝构造的时候，如果是深拷贝的话，那么这个智能指针指向的就不是同一块资源，如果是浅拷贝的话，那么同一块内存会被释放两次。就会出现各种各样的错误。同样赋值也是如此。所以这里我们看一下库里面是怎么解决的。

3. 库里面的智能指针

库里面的只能指针在头文件 memory
这里我们就讲常见的三个只能指针。

3.1 std::auto_ptr

开局即暴击，这个智能指针巨坑坑坑坑坑。废话少说我们根据现象来判断。

void Func()
{
	std::auto_ptr<int> p1(new int(1));
	std::auto_ptr<int> p2(p1);
	
}

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

我们根据调试现象看一看。
在这里插入图片描述
在这里插入图片描述
发生了什么？用p1拷贝构造个p2后，p1确实是拷贝了，但是p2没了。如果后序会用到p2的解引用就是多空指针进行解引用了。是不是非常的坑，而他的底层实现也是非常的简单粗暴。
这auto_ptr进行了管理权限的转移，被拷贝对象把资源管理权限转移给了拷贝对象，导致背靠背对象悬空。

	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~auto_ptr()
		{
			cout << "delete:" << _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;
				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}


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

3.2 std::unique_ptr

而unique_ptr做的就比较直接简单粗暴，你不是拷贝和赋值都有问题吗，那我直接把你给禁止掉，不让你用不就行了。

template<class T>
class unique_ptr
{
public:
	unique_ptr(T* ptr)
		:_ptr(ptr)
	{}

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

	unique_ptr(const unique_ptr<T>& ap) = delete;
	unique_ptr<T>& operator=(const unique_ptr<T>& ap) = delete;

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

3.3 std::shared_ptr

但是有些情况下我们需要用到拷贝构造和赋值呢？所以shared_ptr就解决了这个问题。这里要用到引用计数的概念。

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

	~shared_ptr()
	{
		release();
	}

	void release()
	{
		//最后一个的时候就释放
		if (--(*count) == 0)
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
			delete count;
		}
	}
	int use_count() const
	{
		return *count;
	}

	shared_ptr(const shared_ptr<T>& sp)
	{
		_ptr = sp._ptr;
		count = sp.count;

		//++引用计数
		++(*count);
	}

	shared_ptr& operator=(const shared_ptr<T>& sp)
	{
		//this != &sp 防止自己给自己赋值，因为如果刚开始只有自己，就直接释放了
		if (_ptr != sp._ptr)
		{
			release();
			_ptr = sp._ptr;
			count = sp.count;;

			++(*count);
		}
		return *this;
	}

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

3.3.1shared_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);

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

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

在这里插入图片描述

3.3.2 weak_ptr

这里解决方案就是使用weak_ptr，它的特点就是不遵从RAII，不会是引用计数增加。
在这里插入图片描述

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

	weak_ptr(const shared_ptr<T>& sp)
	{
		_ptr = sp.get(); // == _ptr = sp._ptr;
	}

	weak_ptr& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();// == _ptr = sp._ptr;
		return *this;
	}

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

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

在这里插入图片描述

4.定制删除器

针对于我们上面写的shared_ptr中是是有一点漏洞。当我们之创建一个对象的时候是没什么问题的，但是当我们一下子创建多个对象的时候就会出现问题了。

qfw::shared_ptr<ListNode> p1(new ListNode(10));//这个没什么问题。
qfw::shared_ptr<ListNode> p2(new ListNode[10]);//这个时候就会出现问题了。

因为这个问题中，shared_ptr同时管理的多个new出来的对象，new[]而我们删除的时候是用delete，删除不匹配，这类我们在讲动态管理那一块有详细的讲解，忘记的小伙伴可以在复习一下。所以这里没有和delete[]匹配上，就会出现不完整delete从而报错。

我们看一下库里是怎么实现的。
在这里插入图片描述
库里面是多加了一个定制删除器的构造。我们来使用一下。

template <class T>
class Del
{
public:
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};

int main()
{
	std::shared_ptr<ListNode> p1(new ListNode(10));
	std::shared_ptr<ListNode> p2(new ListNode[10], Del<ListNode>());
	std::shared_ptr<ListNode> p3(new ListNode[10], [](ListNode* ptr) {delete[] ptr; }); //也可以传送lambda表达式
	return 0; 
}

从上面的定制删除器中可以使用operator()，和lambda表达式我们就可以大致猜出库里面使用一个function来实现的，而事实也是如此。

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

	function<void(T*)> _del = [](T* ptr) {delete ptr; };//同一个包装器包装缺省值

	template<class D>
	shared_ptr(T* ptr, D del)
		:_ptr(ptr)
		, count(new int(1))
		,_del(del)//包装可调用对象
	{}

	~shared_ptr()
	{
		release();
	}

	void release()
	{
		//最后一个的时候就释放
		if (--(*count) == 0)
		{
			//cout << "delete:" << _ptr << endl;
			//delete _ptr;
			_del(_ptr);//使用包装器delete
			delete count;
		}
	}
	int use_count() const
	{
		return *count;
	}

	shared_ptr(const shared_ptr<T>& sp)
	{
		_ptr = sp._ptr;
		count = sp.count;

		//++引用计数
		++(*count);
	}

	shared_ptr& operator=(const shared_ptr<T>& sp)
	{
		//this != &sp 防止自己给自己赋值，因为如果刚开始只有自己，就直接释放了
		if (_ptr != sp._ptr)
		{
			release();
			_ptr = sp._ptr;
			count = sp.count;;

			++(*count);
		}
		return *this;
	}

	T& operator* ()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* count;
};
初阳hacker
关注
  • 30
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 5万+
血的教训？不学智能指针，本人丢了一份工作。
C++智能指针详解
qq_61635026的博客
10-02 1416
智能指针是存储指向动态分配（堆）对象指针的类。除了能够在适当的时间自动删除指向的对象外，他们的工作机制很像C++的内置指针。智能指针在面对异常的时候格外有用，因为他们能够确保正确的销毁动态分配的对象。他们也可以用于跟踪被多用户共享的动态分配对象。下面我们先分析一下下面这段程序有没有什么内存方面的问题？ 关于内存泄漏见文章【C++ 内存管理】RAII（Resource Acquisition Is Initialization），也称为 “资源获取就是初始化” ，是一种利用对象生命周期来控制程序资源（如内存
C++ 智能指针
weixin_54670782的博客
12-01 3631
智能指针 输入问题： 给定一个字符串，不知道有几个字符，怎样输入？ 使用cin.getline(); 输入一行。 智能指针概念 智能指针主要是针对裸指针进行了一次面向对象的封装，在构造函数中初始化资源地址，在析构函数中释放资源。当资源应该被释放时，指向它的智能指针可以确保自动释放它。 RAII RAII 对堆上空间进行自动化管理——利用对象自动析构的机制。 malloc， new 等动态分配的对象，很有可能忘记了去释放资源而导致泄露。 对于一个对象而言，在构造函数的时候申请空间，而在析构函数（在离开
c++智能指针详解
热门推荐
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
c++智能指针
08-15
c++ weak_ptr在解决shared ptr中出现的循环引用的左右
C++智能指针测试代码
04-15
C++ 7种智能指针测试代码
c语言操作注意事项
最新发布
dropLin的博客
05-20 115
如果取数据的缓存变量是结构体中的成员，比如。这样操作有可能会造成内存溢出，报硬件中断。主要是用于格式化获取字符串中的数据，来设置1个字节对齐，即不能设置为。这时的结构体类型定义不能加。
C语言之函数指针（持续更新）
qq_47607743的博客
05-20 254
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 901
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 261
C语言如何在链表中的指定位置插⼊结点？
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 933
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
C++ 练习题四道 hv-LDM
m0_73379721的博客
05-14 358
4.文件操作 查找指定字符。1.判断两个日期间的天数。
C++ 复习 -- 构造和析构
mx_jun的博客
05-14 889
类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。构造的是什么呢？构造成员变量的初始化值，内存空间等构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
【华为OD机试-C卷D卷-200分】 简易内存池【C++/Java/Python】
goldarmour的博客
05-14 159
请实现一个简易内存池,根据请求命令完成内存分配和释放。 内存池支持两种操作命令，REQUEST和RELEASE，其格式为： REQUEST=请求的内存大小 表示请求分配指定大小内存，如果分配成功，返回分配到的内存首地址；如果内存不足，或指定的大小为0，则输出error。 RELEASE=释放的内存首地址 表示释放掉之前分配的内存，释放成功无需输出，如果释放不存在的首地址则输出error。
C++智能指针最佳实践
05-02
C++智能指针是一种用于管理动态分配的内存的工具，它可以自动释放内存，避免内存泄漏和悬挂指针的问题。以下是C++智能指针的最佳实践： 1. 使用unique_ptr：unique_ptr是C++11引入的一种独占式智能指针，它确保只有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

初阳hacker

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

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

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

打赏作者

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

抵扣说明：

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

余额充值