C++程序设计——智能指针

最新推荐文章于 2024-07-04 20:45:40 发布
最新推荐文章于 2024-07-04 20:45:40 发布
阅读量288 收藏 1
点赞数 1
分类专栏： C++程序设计 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63020222/article/details/129886895
版权

一、内存泄漏简介

1.什么是内存泄漏

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

2.内存泄漏的危害

        长期运行的程序出现内存泄漏，会造成较大的影响，比如操作系统、服务器等，出现内存泄漏会导致响应越来越慢，最终程序卡死等情况。

3.内存泄漏的分类

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

（1）堆内存泄漏(Heap Leak)

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

（2）系统资源泄漏：

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

4.如何避免内存泄漏

（1）工程前期良好的设计规范，养成良好的编码规范，申请了空间后就记得要匹配的去释放。

（2）采用RAII思想或者智能指针来管理资源。

（3）出现问题了使用内存泄漏工具进行检测。

等等……

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

1. RAII

        RAII是一种利用对象生命周期来控制程序资源的简单技术。

        在对象构造时获取资源，然后控制对资源的访问，使之在对象的生命周期内始终保持有效；最后在对象析构的时候释放资源。

相当于把管理一份资源的责任托管给了一个对象，这样做有两大好处：

（1）不需要显示的释放资源；

（2）对象所需的资源在其生命周期内始终保持有效。

//设计思想---->不完善
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr) 
	{}
	~SmartPtr() {
		if (_ptr) {
			delete _ptr;
			_ptr = nullptr;
		}
	}

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

private:
	T* _ptr;
};
//没有显示实现拷贝构造函数、赋值运算符重载，C++编译器会默认自动生成
//默认生成的拷贝构造函数、赋值运算符重载，采用的是浅拷贝
//通过SmartPtr对象构造另一个对象或赋值时，会导致程序运行崩溃

2.智能指针的原理

（1）RAII特性；

（2）重载operator*和operator->，使对象具有像指针一样的行为；

（3）解决浅拷贝方法。

三、标准库中的智能指针

1. std::auto_ptr

auto_ptr是C++98版本库中提供的智能指针。

1.1 初始版本

实现原理：

（1）RAII特性；

（2）重载operator*和operator->，使对象具有像指针一样的行为；

（3）资源转移的思想，解决浅拷贝。

资源转移思想：

        一旦发生拷贝，就将原对象管理的资源转移到新对象中，旧对象就失去了对资源联系，这样就解决了一块空间被多个对象使用而造成程序崩溃问题。

缺陷：

        不符合我们的使用习惯，对于不熟悉其特性的使用者，可能造成程序崩溃。

模拟实现：

namespace AutoPtr {
	template<class T>
	class auto_ptr {
	public:
		//RAII
		auto_ptr(T* ptr = nullptr)
			: _ptr(ptr)
		{}
		~auto_ptr() {
			if (_ptr) {
				delete _ptr;
				_ptr = nullptr;
			}
		}
		//指针类似行为
		T& operator*() {
			return *_ptr;
		}
		T* operator->() {
			return _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* Get() {
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

1.2 改进版本

技术勘误报告：03标准对auto_ptr进行了改进

实现原理：

（1）RAII特性；

（2）重载operator*和operator->，使对象具有像指针一样的行为；

（3）资源管理权限转移思想，解决浅拷贝。

资源管理权限转移思想：

        发生拷贝时，进行资源拷贝，然后转移资源管理权限（对资源释放的权力）。这样虽然是浅拷贝，但是只有一个对象具有资源的管理权限（对资源释放的权力），就避免了多次释放造成程序崩溃。

缺陷：

（1）致命缺陷：可能导致野指针

        比如一个对象获得了资源管理权限，但是该对象的生命周期比其他共有该资源的对象短，那么该对象在生命周期结束时对资源进行了释放，其他对象内部就成了野指针。

（2）多个对象内指向的是同一个资源，一个对象对其进行了修改，其他对象内也会体现。

所以C++11又将资源管理权限转移的方式，跳回了资源转移的方式。

模拟实现：

namespace AutoPtr_II {
	template<class T>
	class auto_ptr {
	public:
		//RAII
		auto_ptr(T* ptr = nullptr)
			: _ptr(ptr)
			, _owner(false)
		{
			if (_ptr) _owner = true;
		}
		~auto_ptr() {
			//管理了资源，并且用于管理权限，才释放资源
			if (_ptr && _owner) {
				delete _ptr;
				_ptr = nullptr;
				_owner = false;
			}
		}
		//指针类似行为
		T& operator*() {
			return *_ptr;
		}
		T* operator->() {
			return _ptr;
		}
		//解决浅拷贝--》资源管理权限转移思想
		auto_ptr(auto_ptr<T>& ap)
			: _ptr(ap._ptr)
			, _owner(ap._owner)
		{
			//转移管理权限
			ap._owner = false;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& ap) {
			if (this != &ap) {
				//转移之前，若当前对象已经管理了资源，需要先将其释放，再接收新资源
				//否则会造成资源泄漏
				if (_ptr && _owner) {//同理，有管理权限才释放
					delete _ptr;
				}
				//拷贝资源，转移权限
				_ptr = ap._ptr;
				_owner = ap._owner;
				ap._owner = false;
			}
			return *this;
		}

		T* Get() {
			return _ptr;
		}
	private:
		T* _ptr;
		//mutable修饰成员变量，
		//表明const类型对象，或const成员函数内部，可以对该变量进行修改
		mutable bool _owner;
	};
}

2. std::unique_ptr

unique_ptr是C++11版本提供的更靠谱的智能指针。

实现原理：

（1）RAII特性；

（2）重载operator*和operator->，使对象具有像指针一样的行为；

（3）防止拷贝的思想，解决浅拷贝。即资源只能被一个对象管理。

使用场景：

        资源确定不会被共享时。

防止拷贝方法：

（1）C++98：将拷贝构造函数和赋值运算符重载只声明不定义，且设置为private访问权限。

（2）C++11：在要禁止编译器默认生成成员函数的原型后跟上=delete，编译器就不会再自动生成对应的默认成员函数。

针对不同资源释放方法：

        定制删除器，资源释放方法由用户通过模板参数列表传入，默认为delete方式。

缺陷：资源不能共享

模拟实现：

#pragma once

//默认释放方式-->new的资源
template<class T>
class DFDef {
public:
	void operator()(T*& ptr) {
		if (ptr) {
			delete ptr;
			ptr = nullptr;
		}
	}
};
template<class T>
class Free {//处理malloc的资源
public:
	void operator()(T*& ptr) {
		if (ptr) {
			free(ptr);
			ptr = nullptr;
		}
	}
};

class FClose {//处理fopen打开的文件指针
public:
	void operator()(FILE*& pf) {
		if (pf) {
			fclose(pf);
			pf = nullptr;
		}
	}
};

namespace UniquePtr {
	template<class T, class DF = DFDef<T>>
	class unique_ptr {
	public:
		//RAII
		unique_ptr(T* ptr = nullptr)
			: _ptr(ptr)
		{}
		~unique_ptr() {
			if (_ptr) {
				//delete _ptr;//不能直接delete，应该根据资源申请的方式，来进行对应的释放方式
				//解决方法：定制删除器，释放方法由用户传入
				DF()(_ptr);
				_ptr = nullptr;
			}
		}
		//指针类似行为
		T& operator*() {
			return *_ptr;
		}
		T* operator->() {
			return _ptr;
		}
		//解决浅拷贝--》防止拷贝-->资源独占
		// 方法1---C++11
		//在要禁止编译器默认生成成员函数的原型后跟上=delete
		//编译器就不会再自动生成对应的默认成员函数
		//unique_ptr(const unique_ptr<T>&) = delete;
		//unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;

		//方法2---C++98
		//将拷贝构造函数和赋值运算符重载只声明不定义，且设置为private访问权限
	private:
		unique_ptr(const unique_ptr<T>&);
		unique_ptr<T>& operator=(const unique_ptr<T>&);

	public:
		T* Get() {
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

3. std:shared_ptr

3.1 实现原理

shared_ptr是C++11版本提供的更靠谱的，并且支持拷贝的智能指针。

shared_ptr的原理：

        通过引用计数的方式来实现多个shared_ptr对象之间的资源共享。

实现原理：

（1）RAII特性；

（2）重载operator*和operator->，使对象具有像指针一样的行为；

（3）引用计数的思想，解决浅拷贝：

①shared_ptr在其内部，给每个资源都维护了一份计数，用来记录该份资源被几个对象共享。

②在对象被销毁时，说明该对象不再使用该资源，对象的引用计数减一。

③如果引用计数为0，说明该对象是最后一个使用该资源的对象，在销毁时必须释放资源。

④如果引用计数不为0，说明除了自己外，还有其他对象在使用该资源，自己销毁时就不能释放资源，否则其他对象内部就成了野指针。

3.2 线程安全问题

        智能指针对象中的引用计数，是多个智能指针对象所共享的，而对引用计数的++、--操作不是原子操作，多线程环境下就可能对引用计数计数错乱，导致资源没有释放或程序崩溃问题。

        所以对智能指针对象中的引用计数的++、--操作需要加锁保护，确保对引用计数的操作安全性。

注意：shared_ptr保证多线程环境下，对引用计数的操作安全性；但是不保证用户对资源的操作安全性。

3.3 shared_ptr的循环引用

循环引用问题：

        比如：在一个双向链表中，对与每个节点资源通过shared_ptr进行管理，节点内部的next和prev指针域也更换为shared_ptr，那么两个相邻的节点的情况就应该是如下：

 释放链表节点sp2、sp1：

（1）释放sp2时：发现引用计数减一后为1，不为0，那么就不会释放资源。

（2）释放sp1时：发现引用计数减一后为1，不为0，那么就不会释放资源。

最终导致两个节点实际上都没有被释放，造成资源泄漏

解决方式：weak_ptr

注意：

（1）weak_ptr不能单独管理资源（也不能初始化为nullptr）；

（2）weak_ptr也是通过引用计数的原理实现；

（3）weak_ptr存在的唯一作用，就是解决shared_ptr的循环引用问题。

解决原理：

（1）两个双向链表未连接时的初始状态（链表内部的next和prev指针采用的是weak_ptr)：

ps：图内右边的data给错了，应该是10，不影响原理理解

 （2）将两个节点通过next和prev指针域进行连接，使用weak_ptr连接时，引用计数增加的是weak：

 释放链表节点顺序sp2、sp1：

（1）释放sp2时：因为sp2是shared_ptr，所以对use引用计数减一，use变为0，那么说明该资源不能再被使用，会进行释放：先清理内部资源，若遇到weak_ptr且管理了资源，会对其指向的引用计数的weak减一，减一后若引用计数内的use、weak都是0，则会释放掉引用计数资源；随后在释放节点前，会对其引用计数内的weak-1，若weak-1后也为0，则会将引用计数资源也释放掉。

所以sp2在完成释放工作后，左边的引用计数use=1，weak-1=1，节点资源、引用计数资源还存在；右边的引用计数use为0，weak=1，节点被释放，引用计数资源还存在。

（2）释放sp1时：同理按照上述的释放方式。

最终两个节点资源以及引用计数资源都被释放。

3.4 shared_ptr模拟实现

#pragma once
#include <thread>
#include <mutex>
//默认释放方式-->new的资源
template<class T>
class DFDef {
public:
	void operator()(T*& ptr) {
		if (ptr) {
			delete ptr;
			ptr = nullptr;
		}
	}
};
template<class T>
class Free {//处理malloc的资源
public:
	void operator()(T*& ptr) {
		if (ptr) {
			free(ptr);
			ptr = nullptr;
		}
	}
};

class FClose {//处理fopen打开的文件指针
public:
	void operator()(FILE*& pf) {
		if (pf) {
			fclose(pf);
			pf = nullptr;
		}
	}
};

namespace SharedPtr {
	template<class T, class DF = DFDef<T>>
	class shared_ptr {
	public:
		//RAII
		shared_ptr(T* ptr = nullptr)
			: _ptr(ptr)
			, _pCount(nullptr)
			, _mutex(nullptr)
		{
			if (_ptr) {
				_pCount = new int(1);
				_mutex = new std::mutex;
			}
		}
		~shared_ptr() {
			release();
		}

		//指针类型行为
		T& operator*() {
			return *_ptr;
		}
		T* operator->() {
			return _ptr;
		}

		//解决浅拷贝--->引用计数
		shared_ptr(const shared_ptr<T, DF>& sp)
			: _ptr(sp._ptr)
			, _pCount(sp._pCount)
			, _mutex(sp._mutex)
		{
			AddRef();
		}
		shared_ptr<T, DF>& operator=(const shared_ptr<T, DF>& sp) {
			if (this != &sp) {
				//若当前对象已经管理资源
				release();

				//共享sp资源
				_ptr = sp._ptr;
				_pCount = sp._pCount;
				_mutex = sp._mutex;
				AddRef();
			}
			return *this;
		}

		int use_count() const {//返回引用计数
			return *_pCount;
		}
		T* Get() {
			return _ptr;
		}
	private:
		void release() {//资源释放
			//资源存在，且计数减一后为0，说明已经没有对象在使用资源
			if (_ptr && 0 == SubRef()) {
				DF()(_ptr);
				_ptr = nullptr;
				delete _pCount;
				_pCount = nullptr;
				delete _mutex;
				_mutex = nullptr;
			}
		}

		//++、--操作不是原子操作，需要加锁保护
		void AddRef() {//引用计数加一
			if (_pCount) {
				_mutex->lock();
				++(*_pCount);
				_mutex->unlock();
			}
		}
		int& SubRef() {//引用计数减一
			if (_pCount) {
				_mutex->lock();
				--(*_pCount);
				_mutex->unlock();
			}
			return *_pCount;
		}
	private:
		T* _ptr;
		int* _pCount;
		std::mutex* _mutex;//保证多线程环境下，对引用计数的操作安全性
		//但是不保证用户对资源的操作安全性
	};
}

4. 应用场景

auto_ptr：建议什么情况下都不要使用。

unique_ptr：资源确定不需要被共享情况下，可以使用。

shared_ptr：资源共享类型的智能指针

weak_ptr：搭配shared_ptr使用，解决shared_ptr循环引用问题。

Hey小孩
关注
专栏目录
C++智能指针解决内存泄漏问题
程序猿老樊的博客
11-26 7023
在C++开发中，好多程序员经常会被内存泄漏问题困扰，使用智能指针就可以减少内存泄漏。智能指针可以自动删除分配的内存。智能指针和普通指针类似，只是不需要手动释放指针，而是通过智能指针自己管理内存的释放。
数据结构实战开发教程（五）再论智能指针、循环链表的实现、双向链表的实现、双向循环链表的实现、Linux内核链表剖析
Exp.Joker
06-25 674
再论智能指针、循环链表的实现、双向链表的实现、双向循环链表的实现、Linux内核链表剖析
智能指针（解决你的内存泄漏）
weixin_46873777的博客
03-06 2513
智能指针，解决你的单身问题
C++ 智能指针使用不当导致内存泄漏问题
最新发布
m0_59680769的博客
07-04 1148
通过继承MyClass能够安全地在其成员函数中创建返回指向自身的，避免不必要的重复引用计数，从而有效地管理和共享对象生命周期。这样既提升了代码的安全性，也使得对象生命周期管理变得更加简洁和直观。
C++11新特性之智能指针|内存泄漏
jolly0514的博客
09-23 405
内存泄漏:内存泄漏指是因为疏忽或者错误造成程序未能释放已经不再使用的内存情况。内存泄漏并不是指内存在物理上的消息，而是应用程序分配某段内存后，因为涉及错误，失去了对该段内存的控制，造成了内存的浪费。内存泄漏的危害：如os,后台服务等，出现内存泄漏会导致程序响应越来越慢，最终卡死。// 1.内存申请了忘记释放// 2.异常安全问题Func();// 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
C++程序设计——关于世界杯足球赛比赛规则.doc
06-13
综上所述，这个C++程序设计项目涵盖了面向对象编程的核心要素，包括类、继承、多态性，以及如何利用这些概念来模拟实际世界中的复杂系统，如世界杯足球赛的竞赛规则。同时，也展示了C++语言中的基本语法、数据类型、...
【C++详解】——智能指针
weixin_69519040的博客
07-28 800
本文介绍了智能指针：为什么需要智能指针、抛异常引发的内存泄露、智能指针的使用以及原理、RAII思想、auto_ptr unique_ptr shared_ptr weak_ptr的模拟实现。
C++程序设计教程——设计思想与实现习题代码答案
12-07
《C++程序设计教程——设计思想与实现习题代码答案》是一本面向初学者和有一定基础的程序员的教育性资源，旨在帮助读者深入理解和掌握C++编程语言。这本书结合了作者两年的教学实践经验，使得内容既理论严谨又贴近...
C++程序设计第3版 谭浩强 课后答案
02-13
《C++程序设计》一书涵盖了C++的基础语法、控制结构、函数、数组、指针、类与对象、继承、多态、模板等核心概念。课后答案详细解析了每道习题，有助于读者巩固所学，提升编程能力。 1. **基础语法**：包括变量声明...
大一上学期C++课程设计——学生成绩管理系统（QT项目）.zip
08-02
用c++/qt写的项目，项目都经测试过，能跑通，请放心下载使用...其中包括对各类之间的组织细节、各程序模块的具体编写等，进行全面细致的检查和修改，例如将大数据类型以对象指针传递而不拷贝，将简单的for循环展开等。
C++ 智能指针
chi's blog
05-19 1103
在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当导致的。有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用；有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）；没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。C/C++什么是内存泄露，内存泄露如何避免？
什么是内存泄漏（Memory Leaks）？如何检测与避免？如何使用智能指针（如std::unique_ptr和std::shared_ptr）来管理内存？
Aaron的博客
02-20 1268
内存泄漏（Memory Leaks）是指程序在申请内存后，未能释放不再使用的内存空间，导致系统内存的浪费，严重时会导致系统运行缓慢，甚至崩溃。使用智能指针：智能指针（如std::unique_ptr、std::shared_ptr）可以自动管理内存，减少内存泄漏的风险。使用智能指针时，当智能指针离开作用域或被重新赋值时，它会自动释放所管理的内存。避免循环引用：在使用std::shared_ptr时，注意避免循环引用，即对象之间相互引用，导致它们的引用计数永远不会降到0，从而无法释放内存。
C++ 智能指针 unique_ptr 详解与示例
热门推荐
彼此当年少，莫负好时光
12-22 11万+
在本文中，我们将讨论由C++11提供的智能指针std :: unique_ptr&amp;amp;amp;lt;&amp;amp;amp;gt;。 unique_ptr &amp;amp;amp;lt;&amp;amp;amp;gt;是C++ 11提供的用于防止内存泄漏的智能指针中的一种实现。unique_ptr对象包装一个原始指针，并负责其生命周期。当该对象被销毁时，会在其析构函数中删除关联的原始指针。 ...
c++智能指针有没有内存泄露的情况
敖丙007的博客
03-12 701
上述代码中，parent有一个shared_ptr类型的成员指向孩子，而child也有一个shared_ptr类型的成员指向父亲。然后在创建孩子和父亲对象时也使用了智能指针c和p，随后将c和p分别又赋值给child的智能指针成员parent和parent的智能指针成员child。，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共享内存，但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。2.智能指针的内存泄漏如何解决？
c++智能指针内存泄漏的问题
qq_23350817的博客
05-07 1378
使用弱引用wak_ptr来解决智能指针内存泄漏的例子 template <class T> class WeakedPtr; template<class T> class SharePtr { public: friend class WeakedPtr<T>; SharePtr(T* ptr = NULL) :_ptr(ptr), _r...
C++进阶：智能指针
碧瑶的博客呀
10-02 261
为什么需要智能指针 智能指针：管理指针，自动释放资源 智能指针的使用及原理 例如： template <class T> class Smartptr { public: Smartptr(T* ptr = nullptr) :_ptr(ptr) {} ~Smartptr() { if (_ptr) delete[]_ptr; } T& opera...
STM32CubeMX系列|内存管理
安迪西_嵌入式攻城狮
10-13 3755
内存管理 1.内存管理简介 2. 硬件设计 3. 软件设计 3.1 STM32CubeMX设置 3.2 MDK-ARM编程 4. 下载验证
智能指针——从根源上解决内存泄漏的问题
ajt1234的博客
06-21 839
一、什么是内存泄漏 用new在堆中分配内存后，没有调用delete，然后指针所在的内存因为作用域规则而被释放。这时候堆中分配的内存仍在，但是指向它的指针没了，导致程序的整个生命周期内都无法访问这部分内存，也就是说内存泄漏了。 如果程序只运行一次两次，偶尔的内存泄漏，其实问题不大。但是如果程序是一直在运行的，那么连续的内存泄漏，迟早会导致程序崩溃，甚至会导致其他程序的崩溃，因为堆中内存已经耗尽了。 例： void test(){ char* p = new char[1024*1000*100];//分配1
C++程序设计——链表输出详解
6. 程序设计原则：强调了程序的结构性和效率，好的C++程序应该有清晰的结构，便于理解和维护，同时也应考虑程序执行效率，特别是对于大规模系统和科学计算。 通过这个教程，学习者可以掌握如何在C++环境中操作链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Hey小孩

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

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

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

打赏作者

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

抵扣说明：

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

余额充值