C++智能指针深度剖析

已于 2024-03-21 22:35:42 修改
阅读量770 收藏 14
点赞数 8
分类专栏： C++ 文章标签： c++ 智能指针 内存泄漏 RAII C++11
于 2024-03-08 22:38:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czh1592272237/article/details/136573635
版权

文章目录

1. 前言

C++提供了智能指针的概念，它可以自动管理动态分配的内存资源。智能指针是一种对象，它表现得像一个常规指针，但具有附加的内存管理功能。本篇文章将着重讲解智能指针的作用、内存泄漏以及智能指针的使用和原理。

2. 为什么需要智能指针？

在某些场景下，我们在堆上申请了一块空间，但是却无法正常释放。

下面我们先来分析下面这段程序有没有什么内存方面的问题？

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

问题说明：

  1. 如果在 p1 这里使用 new 分配内存时抛出异常，那么异常将传播到 Func() 函数的调用点。由于没有捕获该异常的代码，异常会继续传播到 main() 函数中的异常处理部分。此时，p1 指针没有被成功分配内存，因此不会发生内存泄漏。在异常处理部分，您可以选择适当地清理和处理异常情况。
  2. 如果在 p2 这里使用 new 分配内存时抛出异常，与第一个问题类似，异常也会传播到 Func() 函数的调用点。同样地，没有捕获该异常的代码，它会继续传播到 main() 函数中的异常处理部分。此时，p1 指针已成功分配内存，但 p2 指针没有成功分配内存。因此，在异常处理部分中，您需要确保释放已分配的内存（delete p1）并处理异常情况。
  3. 如果在 div() 函数中抛出异常，它会立即终止函数的执行，并且异常会传播到调用 div() 的地方，也就是 Func() 函数的调用点。同样地，由于没有对该异常进行捕获，它会继续传播到 main() 函数中的异常处理部分。在此过程中，p1 和 p2 指针已成功分配内存，因此您需要确保在异常处理部分中释放已分配的内存（delete p1 和 delete p2）并处理异常情况。

在异常处理部分，我们可以选择清理资源、记录日志或向用户显示错误信息等。同时，确保释放已分配的内存，以避免内存泄漏。在使用 new 分配内存时，可以使用智能指针（如 std::unique_ptr 或 std::shared_ptr）来管理动态内存，而不是手动使用 new 和 delete。智能指针可以自动处理内存释放，避免了手动释放内存的繁琐和容易出错的过程。

3. 内存泄漏

3.1 内存泄漏的概念及危害

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

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

以下是两种内存泄漏的情况：

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	// 2.异常安全问题
	int* p3 = new int[10];
	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放
	delete[] p3;
}

3.2 内存泄漏的分类

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

  • 堆内存泄漏（Heap leak）

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

  • 系统资源泄漏

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

3.3 如何检测内存泄漏

在linux下内存泄漏检测：Linux下几款内存泄露检查工具。
在windows下使用第三方工具：VLD(Visual LeakDetector)内存泄露库。
其他工具：内存泄漏工具比较：内存泄露检测工具比较。

3.4 如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。（这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。）

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

  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

  4. 出问题了使用内存泄漏工具检测。（不过很多工具都不够靠谱，或者收费昂贵。）

总结：

内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

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

4.1 RAII思想

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

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

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

使用RAII思想设计的SmartPtr类

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			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> sp1(new int);
	SmartPtr<int> sp2(new int);
	cout << div() << endl;
}
int main()
{
	try {
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

4.2 智能指针的原理

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

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;
};
struct Date
{
	int _year;
	int _month;
	int _day;
};
int main()
{
	SmartPtr<int> sp(new int);
	*sp = 10;
	SmartPtr<Date> sparray(new Date);
	sparray->_year = 2024;
	sparray->_month = 1;
	sparray->_day = 1;
	return 0;
}

智能指针的原理：

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

4.3 C++智能指针发展历史

思考一下，前面我们简单实现的智能指针存在一个大坑。那就是当一个指针拷贝构造或者赋值给另外一个指针时，由于我们想让两个指针指向同一块空间，所以我们实现的是浅拷贝，但是指向了同一块空间就会有析构函数调用两次的风险。由于这一个大坑，智能指针进行了很多次优化更迭。

  1. 在C++98的时候其实就已经在库中实现了智能指针，也就是第一个智能指针**auto_ptr**。
  • 既然有析构两次的风险，那么auto_ptr在每一次拷贝构造或赋值后直接将自己置空，这样实现了管理权转移。但是对于不了解auto_ptr的人来说，使用它无疑是巨大的风险。
  1. 因此，在很长一段时间里，程序员都习惯于使用boost库中的智能指针（scoped_ptr、shared_ptr和weak_ptr）。
  2. C++11在boost库的基础上完善并推出了unique_ptr、shared_ptr和weak_ptr，这与以上boost库中的三个智能指针相对应。

接下来我们来看看这些智能指针的功能和区别。

4.4 std::auto_ptr

std::auto_ptr文档

C++98版本的库中就提供了auto_ptr的智能指针。下面演示auto_ptr的使用及问题。

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份my_ptr::auto_ptr来了解它的原理。

// C++98 管理权转移 auto_ptr
namespace my_ptr
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._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;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

int main()
{
	std::auto_ptr<int> sp1(new int);
	std::auto_ptr<int> sp2(sp1); // 管理权转移

	// sp1悬空
	*sp2 = 10;
	cout << *sp2 << endl;
	cout << *sp1 << endl; // error
	return 0;
}

auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr。

4.5 std::unique_ptr

unique_ptr文档

unique_ptr的实现原理：独占所有权，简单粗暴的防拷贝，下面简化模拟实现了一份my_ptr::unique_ptr来了解它的原理。

namespace my_ptr
{
	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;
	};
}
int main()
{
	my_ptr::unique_ptr<int> sp1(new int);
	//my_ptr::unique_ptr<int> sp2(sp1); // error

	std::unique_ptr<int> sp1(new int);
	//std::unique_ptr<int> sp2(sp1); // error

	return 0;
}

unique_ptr直接禁用了拷贝和赋值，独占指针所有权，在一些场景下，还是可以用到它的。

4.6 std::shared_ptr

std::shared_ptr文档

shared_ptr是实际运用中使用最多的智能指针，通过引用计数支持拷贝赋值，非常优雅！

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

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

  2. 在对象被销毁时（也就是析构函数调用），就说明自己不使用该资源了，对象的引用计数减一。

  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。

  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

namespace my_ptr
{
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				//cout << "delete->" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

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

		// sp1 = sp3
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				release();

				_ptr = sp._ptr;
				_pcount = sp._pcount;

				++(*_pcount);
			}

			return *this;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

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

4.7 shared_ptr的循环引用问题

请先分析以下代码：

struct ListNode
{
	int _data;
	my_ptr::shared_ptr<ListNode> _prev;
	my_ptr::shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	my_ptr::shared_ptr<ListNode> node1(new ListNode);
	my_ptr::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;
}

输出结果：

在这里插入图片描述

可以看到这里并未调用ListNode的析构函数，为什么呢？

循环引用分析：

  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属于node1的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

图解：

在这里插入图片描述

那么我们如何解决此问题呢？

这里我们就来认识一下专门用来配合shared_ptr使用的指针——weak_ptr。

先来看一下它的简单实现版本：

namespace my_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<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

可以看到weak_ptr用于获得shared_ptr管理的资源的非拥有访问权。通过 weak_ptr，可以检查资源是否存在，weak_ptr不会增加资源的引用计数。

因此上述问题的解决方案就是：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。

struct ListNode
{
	int _data;
	my_ptr::weak_ptr<ListNode> _prev;
	my_ptr::weak_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	my_ptr::shared_ptr<ListNode> node1(new ListNode);
	my_ptr::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;
}

这样node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数，很好的解决了这里的问题。

4.8 定制删除器

当使用智能指针时，会出现下面问题：

shared_ptr<int> sp1(new int[10]);

当调用sp1的析构函数时，默认调用的是delete，而new []应该调用delete []，我们该如何告诉编译器要使用的delete方式呢？

在这里插入图片描述

shared_ptr的构造函数有一个模板参数类型D可以让我们传参要调用的删除方法。

因此，我们可以这样使用：

shared_ptr<int> sp2(new int[10], [](int* ptr) { delete[] ptr; });
shared_ptr<FILE> sp3(fopen("test.txt", "r"), [](FILE* ptr) { fclose(ptr); });

拓展

除了会用，让我们想想shared_ptr该如何实现？

我们可以通过function包装器来定义成员函数去接收构造函数中的删除器参数。

namespace my_ptr
{
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		template<class D>
		shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _pcount(new int(1))
			, _del(del)
		{}

		// function<void(T*)> _del;

		void release()
		{
			if (--(*_pcount) == 0)
			{
				//cout << "delete->" << _ptr << endl;
				//delete _ptr;
				_del(_ptr);

				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

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

		// sp1 = sp3
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				release();

				_ptr = sp._ptr;
				_pcount = sp._pcount;

				++(*_pcount);
			}

			return *this;
		}

		// 像指针一样
		T& operator*()
		{
			return *_ptr;
		}

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

		int use_count() const
		{
			return *_pcount;
		}

		T* get() const
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pcount;

		function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};
}
自信不孤单
关注
  • 8
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C++深度剖析教程16】智能指针的分析
厚积薄发
01-23 1190
今天我们来学习C++中的一个独有的特性，智能指针。智能指针的作用非常的强大，它解决了C++语言关于指针部分内存泄漏的BUG。那么在此处，内存泄漏指的是什么呢？ -动态申请堆空间，用完后不归还 -C++语言中没有垃圾回收机制 -指针无法控制所有堆空间的生命周期 下面我们以一个程序的例子来说明，内存泄漏大概会发生什么情况： #include #include using name
深度剖析智能指针
kittimzhe的博客
08-02 156
一、RAII Resource Acquisition Is Initialization,资源分配即初始化，定义一个类来封装资源的分配和释放，在构造函数完成资源的分配初始化，在析构函数里完成资源的清理。
C++智能指针的解析
XHumble的博客
07-29 113
为什么需要智能指针 是因为我们在没有使用智能指针之前都是使用原生态的指针来管理资源，程序在退出时，原生态的指针不会自动的去释放资源，而c++中还没有支持垃圾回收机制，资源需要用户自己手动进行释放，这就可能由于用户的操作导致内存泄漏，因此用户在写代码时必须要谨慎。 什么是内存泄露，内存泄露的危害 什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不 是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而 造成.
C++智能指针简析
04-07 442
智能指针
C++智能指针shared_ptr分析
08-31
《C++智能指针shared_ptr深度解析》 在C++编程中，智能指针是一种用于自动管理内存的对象，它能够确保在适当的时间自动释放指针所指向的资源，从而避免内存泄漏的问题。其中，`shared_ptr`是C++标准库中的一个智能...
C++11深度剖析.PDF
07-02
《C++11深度剖析》是一本针对C++11标准进行详细解析的书籍，旨在帮助程序员们了解和掌握这一现代C++版本的新特性和改进。C++11是C++语言的重要里程碑，它带来了许多重要的语法更新和性能优化，为开发者提供了更强大...
深度剖析C++对象池自动回收技术实现
08-26
"深度剖析C++对象池自动回收技术实现" 对象池自动回收技术是C++编程中的一种重要技术，旨在提高程序性能和减少资源浪费。今天，我们将深入剖析C++对象池自动回收技术的实现。 对象池的定义 对象池是指预先创建的...
C++深度剖析，面试攻略
01-22
《C++深度剖析，面试攻略》是一本专为C++开发者和求职者设计的高级教程，旨在帮助读者深入理解C++的核心概念和技术，同时提供面试准备的策略与技巧。本书内容丰富，涵盖了从基础语法到高级特性的全面解析，旨在提升...
深度探索C++对象模型
09-29
《深度探索C++对象模型》是一本专注于C++编程语言底层机制的专业书籍，它深入剖析了C++的对象模型，帮助读者理解C++是如何在内存中表示对象、如何实现继承、多态以及模板等核心概念的。这本书对于无论是初入C++殿堂...
c++习题08-计算星期几
码到成龚的博客
07-03 607
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
C++初探究（2）
最新发布
Frenemy__的博客
07-09 1091
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 927
Android 开发中 C++ 和Java 日志调试方法小结
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 929
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 350
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
C语言 do while 循环语句练习 中
2401_84378523的博客
07-05 604
注：使用Sleep首字母必须大写，引用头函数#include <windows.h>，Sleep是延时函数，用来做延时效果。使用system需应用头函数。
C++数据的高效传递--左值引用和右值引用
CHNIM的博客
07-05 376
右值引用主要用于实现移动语义和完美转发。左值引用和右值引用是C++中的两个重要概念。左值引用引用持久存在的对象，而右值引用引用临时对象。通过右值引用，C++实现了移动语义和完美转发，从而提高了程序的效率和灵活性。理解和正确使用它们，对于编写现代、高效的C++代码非常重要。
【LinuxC语言】手撕Http协议之accept_request函数实现(一)
m0_62599305的博客
07-05 474
在计算机网络中，HTTP协议是一种常见的应用层协议，它定义了客户端和服务器之间如何进行数据交换。在这篇文章中，我们将深入探讨Linux C语言中实现HTTP协议的关键部分——accept_request函数。这个函数是服务器处理客户端请求的核心，它负责接收客户端的连接，读取HTTP请求，解析请求内容，并根据请求类型（GET或POST）调用相应的处理函数。我们将详细分析accept_request函数的实现，包括套接字的创建和绑定，监听客户端的连接，接收和解析HTTP请求，以及调用处理函数。
【C语言小知识】缓冲区
dab112的博客
07-06 792
主要讲解了缓冲区的概念
C++智能指针最佳实践
05-02
C++智能指针是一种用于管理动态分配的内存的工具，它可以自动释放内存，避免内存泄漏和悬挂指针的问题。以下是C++智能指针的最佳实践： 1. 使用unique_ptr：unique_ptr是C++11引入的一种独占式智能指针，它确保只有一个指针可以访问给定的资源。在使用动态分配的对象时，应该优先考虑使用unique_ptr。例如： ```cpp std::unique_ptr<int> ptr(new int(10)); ``` 2. 使用shared_ptr：shared_ptr是C++11引入的一种共享式智能指针，它可以被多个指针共享，并且会自动释放资源。当多个指针需要访问同一个资源时，应该使用shared_ptr。例如： ```cpp std::shared_ptr<int> ptr1 = std::make_shared<int>(10); std::shared_ptr<int> ptr2 = ptr1; ``` 3. 避免使用裸指针：尽量避免使用裸指针来管理动态分配的内存，因为容易出现内存泄漏和悬挂指针的问题。使用智能指针可以更安全地管理内存。 4. 使用reset()函数：当不再需要一个智能指针时，可以使用reset()函数将其置为空指针或重新指向其他对象。例如： ```cpp std::unique_ptr<int> ptr(new int(10)); ptr.reset(); // 将指针置为空指针 ``` 5. 避免循环引用：当使用shared_ptr时，要注意避免循环引用的问题，因为它可能导致内存泄漏。可以使用weak_ptr来解决循环引用的问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

自信不孤单

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

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

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

打赏作者

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

抵扣说明：

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

余额充值