C++智能指针

于 2024-05-25 20:13:18 发布
阅读量1.3k 收藏 19
点赞数 24
文章标签： c++ linux 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62697214/article/details/139202692
版权

文章目录

什么是智能指针？

智能指针是一种用于管理动态分配内存的数据结构，通常用于C++等编程语言中。与传统的原始指针相比，智能指针具有自动化内存管理的功能，可以帮助程序员避免内存泄漏和悬空指针等问题。

智能指针通过在其生命周期结束时自动释放其所指向的内存来提供这种自动化管理。这样可以确保在不再需要内存时，内存会被正确地释放，从而减少了内存泄漏的风险。

常见的智能指针类型包括：

  1. shared_ptr：允许多个指针共享同一块内存。内部包含一个引用计数，当最后一个指向内存的shared_ptr被销毁时，内存会被释放。

  2. unique_ptr：独占所指向的内存资源，确保在任何时候只有一个指针可以指向该内存块。当unique_ptr超出其作用域或被销毁时，它所指向的内存会被自动释放。

  3. weak_ptr：用于解决shared_ptr的循环引用问题，它不会增加引用计数。通常与shared_ptr配合使用，用于观察资源是否已被释放。

使用智能指针可以提高代码的安全性和可靠性，减少了手动管理内存的复杂性，但仍需注意避免循环引用等问题。

内存泄露

什么是内存泄露，内存泄露的危害

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

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

内存泄露分类

  • 堆内存泄露(Heap leak)

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

  • 系统资源泄露

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

如何避免内存泄露

  1. 有良好的设计规范和良好的编码规范，申请的内存空间记得匹配的去释放。(手动控制很难做到完美)
  2. 采用RAII思想或智能指针来管理资源。(下文会说明)

智能指针的使用及原理

RAII

RAII（Resource Acquisition Is Initialization）是一种C++编程中的重要技术，它利用对象的生命周期来管理资源的获取和释放，从而确保资源在不再需要时被正确释放，避免资源泄漏。

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

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

智能指针原理

智能指针，浅拷贝，只是代替管理资源。

首先使用RAII思想设计的SmartPtr类

想要有指针的行为，这个模板类中还需要重载 * 、->，才能让其像指针一样使用。

template<class T>
class SmartPtr {
public:

	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	~SmartPtr()
	{
		if (_ptr)
		{
			cout << "delete->" << _ptr<<endl;
			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> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;
	SmartPtr<Date> sparray(new Date);
	// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
	// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
	sparray->_year = 2018;
	sparray->_month = 1;
	sparray->_day = 1;

}

在这里插入图片描述

总结智能指针的原理：

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

std::auto_ptr

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

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

// C++98 管理权转移 auto_ptr
namespace Nir
{
	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;
	};
}

// 结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_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;
	 return 0;
}

在这里插入图片描述

在这里插入图片描述

std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理。

// C++11库才更新智能指针实现
// C++11出来之前，boost搞出了更好用的scoped_ptr/shared_ptr/weak_ptr
// C++11将boost库中智能指针精华部分吸收了过来
// C++11->unique_ptr/shared_ptr/weak_ptr

// unique_ptr/scoped_ptr
// 原理：简单粗暴 -- 防拷贝
namespace Nir
{
	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()
{
	 Nir::unique_ptr<int> sp1(new int);
	 Nir::unique_ptr<int> sp2(sp1);

	 std::unique_ptr<int> sp3(new int);
	 std::unique_ptr<int> sp4(sp3);

 return 0;
}

在这里插入图片描述

在这里插入图片描述

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。例如：早八上课最后一个离开宿舍的人关门。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源。
  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。
namespace Nir
{
	template<class T>
	class shared_ptr
	{
	public:
		// RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			// 拷贝时++计数
			++(*_pcount);
		}

		// sp1 = sp4
		// sp4 = sp4;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)	//当指向资源不同时再进行赋值拷贝，防止指向资源相同时再次拷贝使得计数+1
			{
				release();	//先释放当前指向的资源(或者是当前指向的资源计数减1)

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

				// 拷贝时++计数
				++(*_pcount);
			}

			return *this;
		}

		void release()
		{
			// 说明最后一个管理对象析构了，可以释放资源了
			if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			// 析构时，--计数，计数减到0，
			release();
		}

		int use_count()
		{
			return *_pcount;
		}

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

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

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
	};
    
    
    
	// 简化版本的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;
	};
}



int main()
{
	 Nir::shared_ptr<int> sp1(new int);
	 Nir::shared_ptr<int> sp2(sp1);
	 Nir::shared_ptr<int> sp3(sp1);
	 cout << sp1.use_count() << endl;
	 Nir::shared_ptr<int> sp4(new int);
	 Nir::shared_ptr<int> sp5(sp4);
	 cout << sp4.use_count() << endl;

	 sp1 = sp1;
	 sp1 = sp2;
	 cout << sp1.use_count() << endl;

	 sp1 = sp4;
	 sp2 = sp4;
	 sp3 = sp4;
	 cout << sp1.use_count() << endl;

	 *sp1 = 2;
	 *sp2 = 3;

	 return 0;
}

在这里插入图片描述

std::shared_ptr的循环引用

 //shared_ptr的缺陷
struct ListNode
{
	int _val;

	Nir::shared_ptr<ListNode> _next;
	Nir::shared_ptr<ListNode> _prev;

	//Nir::weak_ptr<ListNode> _next;
	//Nir::weak_ptr<ListNode> _prev;

	ListNode(int val = 0)
		:_val(val)
	{}

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

int main()
{
	Nir::shared_ptr<ListNode> n1(new ListNode(10));
	Nir::shared_ptr<ListNode> n2(new ListNode(20));

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	n1->_next = n2;
	n2->_prev = n1;

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;



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

在这里插入图片描述

循环引用解决(weak_ptr)

weak_ptr无引用计数，不支持RAII(即构造时直接将对象的生命周期与自己绑在一起)，不参与资源管理。

// 解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
// 原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

struct ListNode
{
	int _val;

	Nir::weak_ptr<ListNode> _next;
	Nir::weak_ptr<ListNode> _prev;

	ListNode(int val = 0)
		:_val(val)
	{}

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

int main()
{
	Nir::shared_ptr<ListNode> n1(new ListNode(10));
	Nir::shared_ptr<ListNode> n2(new ListNode(20));

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	n1->_next = n2;
	n2->_prev = n1;

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;



	return 0;
}

删除器管理资源

使用删除器管理资源，可以自定义删除器，以确保自定义资源能够得到正确的释放。

利用仿函数或者lambda表达式来自定义删除器。

namespace Nir
{
	template<class T>
	class shared_ptr
	{
	public:

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


		// RAII
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_pcount = sp._pcount;

			// 拷贝时++计数
			++(*_pcount);
		}

		// sp1 = sp4
		// sp4 = sp4;
		// sp1 = sp2;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)		//防止自己给自己拷贝  (释放自己)
			if (_ptr != sp._ptr)	//当指向资源不同时再进行赋值拷贝(优化)
			{
				release();	//先释放当前指向的资源(或者是当前指向的资源计数减1)

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

				// 拷贝时++计数
				++(*_pcount);
			}

			return *this;
		}

		void release()
		{
			// 说明最后一个管理对象析构了，可以释放资源了
			if (--(*_pcount) == 0)
			{
				cout << "delete:" << _ptr << endl;
				_del(_ptr);
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			// 析构时，--计数，计数减到0，
			release();
		}

		int use_count()
		{
			return *_pcount;
		}

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

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

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
		function<void(T*)> _del = [](T* ptr) {delete 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;
	};
}



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

//int main()
//{
//	std::shared_ptr<ListNode> p1(new ListNode(10));
//	std::shared_ptr<ListNode[]> p2(new ListNode[10]);  //可以的
//
//	std::shared_ptr<ListNode> p3(new ListNode[10], DeleteArray<ListNode>());
//	std::shared_ptr<FILE> p4(fopen("Test.cpp", "r"), [](FILE* ptr) {fclose(ptr); });
//
//	return 0;
//}
int main()
{
	Nir::shared_ptr<ListNode> p1(new ListNode(10));
    
    //保证资源的正确释放
	Nir::shared_ptr<ListNode> p2(new ListNode[10], DeleteArray<ListNode>());
	
    Nir::shared_ptr<FILE> p3(fopen("Test.cpp", "r"), [](FILE* ptr) {fclose(ptr); });

	return 0;
}

char*类型指针

char* 类型打印地址要强转为 void*，因为编译器会默认认为要打印字符串，其他类型不需要。

int main()
{
	char* p1 = new char[1024 * 1024 * 1024];
	cout << p1 << endl;

	return 0;
}

在这里插入图片描述

int main()
{
	char* p1 = new char[1024 * 1024 * 1024];
	cout << (void*)p1 << endl;

	return 0;
}

在这里插入图片描述

C++11和boost中智能指针的关系

  1. C++ 98中产生了第一个智能指针auto_ptr
  2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr
  3. C++ TR1，引入了shared_ptr等，不过TR1并不是标准版
  4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr，unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的
暗暗十分
关注
  • 24
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
四、c++11智能指针之shared_ptr实现：自定义删除器
Chiang11的博客
06-12 1667
private ://指向计数器的指针 T * m_ptr;//多个智能指针对象共享一个引用计数，因此要定义为指针 size_t * m_size;//数组大小 std : : mutex * m_mutex;// 互斥锁，定义为指针类型，仅仅用来保护引用计数器 public ://构造 mySharedSp(const mySharedSp < T > & other);
68 CPP 智能指针的删除器
wade1010的专栏
12-28 447
c++
C++智能指针 shared_ptr 精简 教程
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-17 974
C++智能指针 shared_ptr 精简 教程
C++学习笔记：智能指针删除器
qq_45834144的博客
08-25 659
智能指针删除器
C++智能指针自定义删除器
转载和创作优秀的博客
08-03 870
C++智能指针自定义删除器
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++智能指针
08-15
c++ weak_ptr在解决shared ptr中出现的循环引用的左右
C++智能指针测试代码
04-15
C++ 7种智能指针测试代码
C++智能指针实现（不用再担心你的内存泄露）
03-24
代码量，2.5KB，指针共享操作，自动在最后一个智能指针销毁时delete，不再产生内存泄露。内含简单使用范例。不支持管理数组。设有Debug版本的断言，确保智能空指针不被使用。 /* 智能指针类 不能用于数组，指针指向的数据必须是new出来的 不能创造该类的指针 不能将任意实体指针分别赋值给两个不同的智能指针（通过构造函数或者=） */
【C++】定制删除器 + 类型转换
上上谦. 的博客
03-20 649
上一章节我们学习了智能指针，我们可以将对象托管给智能指针管理，通过智能指针来释放资源空间。但是每个资源的释放的方式是不一样的，而我们之前实现的智能指针释放资源的方式单一，那我们该如何解决呢？下面来絮叨絮叨~~🙋🙋🙋🙌传送门。
shared_ptr数组一般删除器、标准库删除器、lambda删除器
weixin_43133099的博客
10-03 225
shared_ptr数组一般删除器、标准库删除器、lambda删除器
C++智能指针_主动销毁智能指针的方法，【大牛疯狂教学
2301_79097795的博客
04-17 1015
6.但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。涉及到共享，我们不得不将线程安全问题考虑进来，很显然shared_ptr无论是要管理的资源的使用，还是要指向的该资源对应的计数器的加减操作，都不是线程安全的。3.node1和node2析构，引用计数减到1，但是_next还指向下一个节点。2.node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
C++ - 智能指针(smarter pointer)自定义删除器(deleter) 的方法 详解 及 代码
weixin_34187862的博客
11-25 760
智能指针(smarter pointer)自定义删除器(deleter) 的方法 详解 及 代码 版权所有, 禁止转载, 如有需要, 请站内联系 本文地址: http://blog.csdn.net/caroline_wendy 智能指针包含两种"shared_ptr"和"unique_ptr", 由于两种指针的实现方式不同, 所以传递删除器的方式也不同; ...
std::unique_ptr智能指针定制删除器在连接池中的应用
征途开始的小窝(^_^)
11-17 859
用智能指针管理连接池（如数据库连接池、redis连接池），当智能指针离开作用域时，调用定制的删除器，删除器中调用指定的函数，并不是将连接断开，而是将连接放进一个容器中。当需要获取连接时，从连接池中获取一个空闲的连接。 目录 自定义删除器 scoped_ptr.h api_redis.h main.cpp 自定义删除器 scoped_ptr.h #ifndef SCOPED_PTR_H_INCLUDED #define SCOPED_PTR_H_INCLUDED #include <i
C++ primer 学习笔记-智能指针自定义删除器
weixin_43471255的博客
03-18 1287
默认情况下，智能指针使用delete释放其管理的资源，有时候，可能要修改默认使用delete释放资源的行为。本文将列出我所知道的所有自定义删除器的方法。 shared_ptr使用删除器格式 unique_ptr 使用删除器格式 例子: Connection是一个管理连接类，在释放Connection之前，我们需要调用close函数来关闭连接。观察如下代码： class Connection { public: Connection() = default; explicit Connec
C++ 智能指针shared_ptr/unique_ptr自定义删除器
热门推荐
Marvek的博客
03-16 1万+
默认情况下，智能指针使用delete释放其管理的资源，有时候，可能要修改默认使用delete释放资源的行为。本文将列出我所知道的所有自定义删除器的方法。 目录零、引例一、使用函数二、使用可调用类三、使用lambda表达式四、使用std::function 零、引例 Connection是一个管理连接类，在释放Connection之前，我们需要调用close函数来关闭连接。观察如下代码： #incl...
c++11 智能指针删除器
u012592081的专栏
07-22 2020
其实很简单自己上代码： #include #include #include #include #include using namespace std; struct struct_s { int i; }; void delete_struct(struct_s* p) { printf("hehe\n"); free(p); p=NU
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
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值