C++智能指针和内存泄漏

本文系统介绍了C++智能指针的核心概念与应用。首先分析了传统指针在异常处理时容易导致内存泄漏的问题，阐述了RAII（资源获取即初始化）设计思想，指出智能指针通过对象生命周期管理资源。详细讲解了标准库提供的auto_ptr（已废弃）、unique_ptr（独占所有权）、shared_ptr（共享所有权）和weak_ptr（解决循环引用）四种智能指针的特性与适用场景。通过代码示例展示了智能指针的实现原

keyipatience

838人浏览 · 2026-02-28 19:40:34

keyipatience · 2026-02-28 19:40:34 发布

🔥keyipatience:个人主页

🎬作者简介：C/C++后端开发学习者

🌟专栏传送门：《c++》

⭐️patience is key in life

1. 智能指针的使用场景分析

下⾯程序中我们可以看到，new了以后，我们也delete了，但是因为抛异常导，后⾯的delete没有得到执⾏，所以就内存泄漏了，所以我们需要new以后捕获异常，捕获到异常后delete内存，再把异常抛出，但是因为new本⾝也可能抛异常，连续的两个new和下⾯的Divide都可能会抛异常，让我们处理起来很⿇烦。智能指针放到这样的场景⾥⾯就让问题简单多了。

2.RAII和智能指针的设计思路

• RAII是Resource Acquisition Is Initialization的缩写，他是⼀种管理资源的类的设计思想，本质是⼀种利⽤对象⽣命周期来管理获取到的动态资源，避免资源泄漏，这里的资源可以是内存、⽂件指针、网络连接、互斥锁等等。RAII在获取资源时把资源委托给⼀个对象，接着控制对资源的访问，资源在对象的⽣命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。

• 智能指针类除了满足RAII的设计思路，还要方便资源的访问，所以智能指针类还会想迭代器类⼀样，重载 operator*/operator->/operator[] 等运算符，方便访问资源。

智能指针只是代管资源，和容器不一样（容器是拥有一块资源）模拟指针的行为，访问修改资源，所以拷贝只需浅拷贝

函数3->函数2->函数1

3个函数为调用关系，如果函数1 throw后直接去函数3，那么由前面异常的知识会销毁函数2中的对象，现在有智能指针把资源给函数2对象，对象销毁资源不就也释放了吗？

main()调用func()调用Divide()，如果Divide()抛异常throw后，func()不接受，main()接受由智能指针和异常知识，会销毁func()中的s1和s2对象，那么资源也得到了释放

3. C++标准库智能指针的使用

• C++标准库中的智能指针都在<memory>这个头⽂件下⾯，我们包含就可以使⽤了，智能指针有好⼏种，除了weak_ptr他们都符合RAII和像指针⼀样访问的⾏为，原理上而言主要是解决智能指针拷⻉时的思路不同。

• auto_ptr是C++98时设计出来的智能指针，他的特点是拷⻉时把被拷⻉对象的资源的管理权转移给拷⻉对象，这是⼀个⾮常糟糕的设计，因为他会让被拷⻉对象悬空，访问报错的问题，C++11设计出新的智能指针后，强烈建议不要使⽤auto_ptr。其他C++11出来之前很多公司也是明令禁⽌使⽤这个智能指针的。

• unique_ptr是C++11设计出来的智能指针，他的名字翻译出来是唯⼀指针，他的特点的不⽀持拷⻉，只⽀持移动。如果不需要拷⻉的场景就⾮常建议使⽤他。

• shared_ptr是C++11设计出来的智能指针，他的名字翻译出来是共享指针，他的特点是⽀持拷⻉，也⽀持移动。如果需要拷⻉的场景就需要使⽤他了。底层是⽤引⽤计数的⽅式实现的。

• weak_ptr是C++11设计出来的智能指针，他的名字翻译出来是弱指针，他完全不同于上面的智能指针，他不⽀持RAII，也就意味着不能⽤它直接管理资源，weak_ptr的产⽣本质是要解决shared_ptr 的⼀个循环引⽤导致内存泄漏的问题。具体细节下⾯我们再细讲。

• 智能指针析构时默认是进⾏delete释放资源，这也就意味着如果不是new出来的资源，交给智能指针管理，析构时就会崩溃。智能指针⽀持在构造时给⼀个删除器，所谓删除器本质就是⼀个可调⽤对象，这个可调⽤对象中实现你想要的释放资源的⽅式，当构造智能指针时，给了定制的删除器，在智能指针析构时就会调⽤删除器去释放资源。因为new[]经常使⽤，所以为了简洁⼀点， unique_ptr和shared_ptr都特化了⼀份[]的版本，使⽤时 unique_ptr up1(new Date[5]);shared_ptr sp1(new Date[5]); 就可以管理new[]的资源。

unique_ptr和shared_ptr⽀持删除器的⽅式有所不同，unique_ptr是在类模板参数⽀持的，shared_ptr是构造函数参数⽀持的，这⾥没有使⽤相同的⽅式还是挺坑的，使⽤仿函数unique_ptr可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调⽤，但是下⾯的函数指针和lambda的类型不可以

总结：unique_str就用仿函数最方便，shared_ptr都可以

• shared_ptr 除了⽀持⽤指向资源的指针构造，还⽀持 make_shared ⽤初始化资源对象的值直接构造。

• shared_ptr 和 unique_ptr 都⽀持了operator bool的类型转换，如果智能指针对象是⼀个空对象没有管理资源，则返回false，否则返回true，意味着我们可以直接把智能指针对象给if判断是否为空。

• shared_ptr 和 unique_ptr 都得构造函数都使用explicit修饰，防⽌普通指针隐式类型转换成智能指针对象。

4. 智能指针的原理

• 下⾯我们模拟实现了auto_ptr和unique_ptr的核⼼功能，这两个智能指针的实现⽐较简单，⼤家了解⼀下原理即可。auto_ptr的思路是拷⻉时转移资源管理权给被拷⻉对象，这种思路是不被认可的，也不建议使⽤。unique_ptr的思路是不⽀持拷⻉。

• ⼤家重点要看看shared_ptr是如何设计的，尤其是引⽤计数的设计，主要这⾥⼀份资源就需要⼀个引⽤计数，所以引⽤计数才⽤静态成员的⽅式是⽆法实现的（静态成员static是所有资源共用一个计数），要使⽤堆上动态开辟的⽅式，构造智能指针对象时来⼀份资源，就要new⼀个引⽤计数出来。多个shared_ptr指向资源时就++引⽤计数，shared_ptr对象析构时就--引⽤计数，引⽤计数减到0时代表当前析构的shared_ptr是最后⼀个管理资源的对象，则析构资源。

auto_ptr:

namespace bit
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{ }
		~auto_ptr()
		{
			if (_ptr)
			{
				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;
	};
}
int main()
{
	bit::auto_ptr<int>a1(new int[2]);
	bit::auto_ptr<int>a2(a1);
	a2 = a1;
}

unique_ptr:

namespace bit
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T*ptr)
			:_ptr(ptr)
		{ }
		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			} 
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(unique_ptr& up) = delete;
		unique_ptr<T>operator=(unique_ptr& up) = delete;
		unique_ptr(unique_ptr&& up)
			:_ptr(up._ptr)
		{
			up._ptr = nullptr;
		}
		unique_ptr<T>operator=(unique_ptr&& up)
		{
				delete _ptr;
				_ptr = up._ptr;
				up._ptr = nullptr;
		}
	private:
		T* _ptr;
	};
}
int main()
{
	unique_ptr<int>up1(new int);
	//unique_ptr<int>up2(up1);
	unique_ptr<int>up3(move(up1));
	up3 = move(up1);
	return 0;
}

shared_ptr:

#include<functional>
namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		explicit shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

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

		~shared_ptr()
		{
			(*_pcount)--;
			if (*_pcount == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _pcount;
				_ptr = nullptr;
				_pcount = nullptr;
				
			}
		}
		shared_ptr(shared_ptr& sp1)
			:_ptr(sp1._ptr)
			,_pcount(sp1._pcount)
			,_del(sp1._del)
		{
			(*_pcount)++;
		}
		shared_ptr<T>operator=(shared_ptr& sp1)
		{
			if (_ptr != sp1._ptr)
			{
				--(*_pcount);
				if (*_pcount == 0)
				{
					_del(_ptr);
					delete _pcount;
					_ptr = nullptr;
					_pcount = nullptr;
				}
				_ptr = sp1._ptr;
				_del = sp1._del;
				_pcount = sp1._pcount;//不是给数量，而是让this管理数量的空间和sp1一样
				++(*_pcount);
			}
			return *this;
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		int use_count()
		{
			return *_pcount;
		}
	private:
		int* _pcount;
		T* _ptr;
		function<void(T*)>_del = [](T* ptr) {delete ptr; };
	};
}
template<class T>
int main()
{
	bit::shared_ptr<int>sp1(new int);
	bit::shared_ptr<int>sp2(sp1);
	bit::shared_ptr<int>sp3(new int[12], [](T* ptr) {
		delete[]ptr;
		});

	return 0;
}

5. shared_ptr和weak_ptr

5.1 shared_ptr循环引⽤问题

• shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会导致资源没得到释放内存泄漏，所以我们要认识循环引⽤的场景和资源没释放的原因，并且学会使用weak_ptr解决这种问题。

• 如下图所述场景，n1和n2析构后，管理两个节点的引⽤计数减到1

1. 右边的节点什么时候释放呢，左边节点中的_next管着呢，_next析构后，右边的节点就释放了。

2. _next什么时候析构呢，_next是左边节点的的成员，左边节点释放，_next就析构了。

3. 左边节点什么时候释放呢，左边节点由右边节点中的_prev管着呢，_prev析构后，左边的节点就释放了。

4. _prev什么时候析构呢，_prev是右边节点的成员，右边节点释放，_prev就析构了。

• ⾄此逻辑上成功形成回旋镖似的循环引⽤，谁都不会释放就形成了循环引⽤，导致内存泄漏

• 把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的引⽤计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引⽤，解决了这⾥的问题

5.2 weak_ptr

• weak_ptr不⽀持RAII，也不⽀持访问资源，所以我们看⽂档发现weak_ptr构造时不⽀持绑定到资源，只⽀持绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引⽤计数，那么就可以解决上述的循环引⽤问题。

• weak_ptr也没有重载operator*和operator->等，因为他不参与资源管理，那么如果他绑定的 shared_ptr已经释放了资源，那么他去访问资源就是很危险的。weak_ptr⽀持expired检查指向的资源是否过期，use_count也可获取shared_ptr的引⽤计数，weak_ptr想访问资源时，可以调⽤ lock返回⼀个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是⼀个空对象，如果资源没有释放，则通过返回的shared_ptr访问资源是安全的。

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

• Boost库是为C++语⾔标准库提供扩展的⼀些C++程序库的总称，Boost社区建⽴的初衷之⼀就是为 C++的标准化⼯作提供可供参考的实现，Boost社区的发起⼈Dawes本⼈就是C++标准委员会的成员之⼀。在Boost库的开发中，Boost社区也在这个⽅向上取得了丰硕的成果，C++11及之后的新语法和库有很多都是从Boost中来的。

• C++98中产⽣了第⼀个智能指针auto_ptr。

• C++boost给出了更实⽤的scoped_ptr/scoped_array和shared_ptr/shared_array和weak_ptr等.

• C++TR1，引⼊了shared_ptr等，不过注意的是TR1并不是标准版。

• C++11，引⼊了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的 scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。