【C++】智能指针

月亮有痕迹诶2025-04-02 16:52

目录

前言

一、为什么需要智能指针

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

[2.1 RAII](#2.1 RAII)

[2.2 智能指针的原理](#2.2 智能指针的原理)

[2.3 std::auto_ptr](#2.3 std::auto_ptr)

[2.4 std::unique_ptr](#2.4 std::unique_ptr)

[2.5 std::shared_ptr](#2.5 std::shared_ptr)

[2.5.1 std::shared_ptr的原理](#2.5.1 std::shared_ptr的原理)

[2.5.2 std::shared_ptr的线程安全问题](#2.5.2 std::shared_ptr的线程安全问题)

[2.5.3 循环引用和std::weak_ptr](#2.5.3 循环引用和std::weak_ptr)

[2.5.4 自定义删除器](#2.5.4 自定义删除器)

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

总结

前言

前言

在C++编程中，内存管理一直是开发者面临的核心挑战之一。传统指针需要手动申请和释放资源，稍有不慎便会导致内存泄漏、悬垂指针等问题，尤其在异常抛出或复杂逻辑中，资源释放的可靠性难以保证。智能指针的出现，正是为了解决这些痛点。它通过RAII（Resource Acquisition Is Initialization）机制，将资源的生命周期与对象的生命周期绑定，实现了自动化的资源管理，极大提升了代码的安全性和可维护性。

本文将从内存泄漏的典型案例出发，分析传统指针的局限性，逐步深入探讨智能指针的设计原理与实现方式。通过介绍auto_ptr、unique_ptr、shared_ptr和weak_ptr等主流智能指针的特性，结合线程安全、循环引用等高级话题，帮助读者全面理解智能指针的底层逻辑与适用场景。无论您是初探智能指针的新手，还是希望深化理解的进阶开发者，本文都将为您提供清晰的指引和实用的知识。

一、为什么需要智能指针

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

cpp 复制代码 
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抛异常会如何？

如果p1 new抛异常的话，因为内存没申请出来，所以不会有什么问题。

2、如果p2这里new抛异常会如何？

如果p2 new抛异常的话，会导致p1申请的内存没释放，所以会导致内存泄漏。

3、如果div调用这里又会抛异常会如何？

如果div抛异常的话，会导致p1和p2申请的内存都没释放，所以也会导致内存泄漏。

关于内存泄漏，可以参考内存管理文章中的内容：

C/C++内存管理-CSDN博客

如果要解决上述问题的话就需要嵌套的捕捉异常并释放内存，代码如下：

cpp 复制代码 
void Func()
{
	int* p1 = new int;
	int* p2 = nullptr;
	try
	{
		p2 = new int;
		try
		{
			cout << div() << endl; // throw
		}
		catch (...)
		{
			delete p2;

			throw;  // 捕获什么抛出什么
		}
	}
	catch (...)
	{
		delete p1;

		throw;
	}

	delete p1;
	delete p2;
}

但是这样的代码又显得很繁杂，如果指针不止两个呢，那又需要嵌套几层？这时候就需要智能指针了。

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

2.1 RAII

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

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

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

下面是使用RAII思想设计的SmartPtr类来解决上面问题：

cpp 复制代码 
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 (exception& e)
	{
		cout << e.what() << endl;
	}

	return 0;
}

2.2 智能指针的原理

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

cpp 复制代码 
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> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;

	SmartPtr<Date> sparray(new Date);
	// 需要注意的是这里应该是sparray.operator->()->_year = 2025;
	// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
	sparray->_year = 2025;
	sparray->_month = 1;
	sparray->_day = 1;

	return 0;
}

总结一下智能指针的原理：

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

2.3 std::auto_ptr

auto_ptr文档

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

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

cpp 复制代码 
// C++98 管理权转移 auto_ptr
namespace hang
{
	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()
{
	// 这里使用库中的auto_ptr演示
	std::auto_ptr<int> sp1(new int);
	std::auto_ptr<int> sp2(sp1); // 管理权转移

	// sp1悬空
	*sp2 = 10;
	cout << *sp2 << endl;
	cout << *sp1 << endl;

	return 0;
}

2.4 std::unique_ptr

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

unique_ptr文档

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

cpp 复制代码 
// 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 hang
{
	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()
{
	hang::unique_ptr<int> sp1(new int);
	//hang::unique_ptr<int> sp2(sp1);

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

	return 0;
}

2.5 std::shared_ptr

2.5.1 std::shared_ptr的原理

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

shared_ptr文档

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

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

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

		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			: _ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
			, _del(sp._del)
		{
			_pmtx->lock();
			(*_pcount)++;
			_pmtx->unlock();
		}

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

				_ptr = sp._ptr;
				_pcount = sp._pcount;
				_pmtx = sp._pmtx;
				_del = sp._del;

				_pmtx->lock();
				(*_pcount)++;
				_pmtx->unlock();
			}

			return *this;
		}

		void release()
		{
			_pmtx->lock();
			bool flag = false;
			if (--(*_pcount) == 0)
			{
				// 最后一个管理的对象，释放资源
				//delete _ptr;
				_del(_ptr);

				delete _pcount;
				flag = true;
			}
			_pmtx->unlock();
			if (flag == true)
			{
				delete _pmtx;
			}
		}

		~shared_ptr()
		{
			release();
		}

		int use_count()
		{
			return *_pcount;
		}

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

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

	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;

		function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};
}

2.5.2 std::shared_ptr的线程安全问题

查看上面的代码，可以发现，在引用计数++和--的时候，都加了锁**（当然也可以不用加锁，只要将引用计数定义成原子类型变量就行，这样更简单）** ，**为什么要加锁呢？**通过下面的程序我们来测试shared_ptr的线程安全问题。

注意要将++和--前的锁去掉，运行一次可能不出现线程安全问题，因为线程安全问题是偶现性问题，main函数的n改大一些概率就变大了，就容易出现了。最好也把自定义删除器那些代码去掉，不然程序会一直崩溃，因为线程不安全的程序会出现各种意外的情况 。

cpp 复制代码 
mutex mtx;

// 智能指针对象本身拷贝析构是线程安全的
// 底层引用计数加减是线程安全的
// 指向的资源访问不是线程安全的
void func(hang::shared_ptr<list<int>> sp, int n)
{
	cout << sp.use_count() << endl;

	for (int i = 0; i < n; i++)
	{
		hang::shared_ptr<list<int>> copy1(sp);
		hang::shared_ptr<list<int>> copy2(sp);
		hang::shared_ptr<list<int>> copy3(sp);

		mtx.lock();
		sp->emplace_back(i);
		mtx.unlock();
	}
}

int main()
{
	hang::shared_ptr<list<int>> sp1(new list<int>);
	cout << sp1.use_count() << endl;

	thread t1(func, sp1, 100000);
	thread t2(func, sp1, 200000);

	t1.join();
	t2.join();

	cout << sp1->size() << endl;
	cout << sp1.use_count() << endl;

	return 0;
}

需要注意的是shared_ptr的线程安全分为两方面：

  1. 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2，这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以只能指针中引用计数++、--是需要加锁的，也就是说引用计数的操作是线程安全的。
  2. 智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

2.5.3 循环引用和std::weak_ptr

std::shared_prt还有一个问题，那就是它可能会出现循环引用的情况。

循环引用：当两个或多个对象通过智能指针相互引用时，会导致引用计数无法归零，从而引发内存泄漏。

cpp 复制代码 
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);

	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;
}

运行上面代码后，可以发现并没有new出来的对象在程序结束后，并没有调用析构函数，因为这里出现了循环引用。

循环引用分析：

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

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

原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

cpp 复制代码 
struct ListNode
{
	int _data;
	weak_ptr<ListNode> _prev;
	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;
}

weak_ptr文档

简化版本的weak_ptr实现 ：

cpp 复制代码 
namespace hang
{
	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;
	};
}

2.5.4 自定义删除器

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题（unique_ptr也有删除器）

cpp 复制代码 
class A
{
public:
	A(int a1 = 0, int a2 = 0)
		: _a1(a1)
		, _a2(a2)
	{
	}

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

private:
	int _a1 = 1;
	int _a2 = 1;
};

template<class T>
struct FreeFunc
{
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

// 定制删除器
int main()
{
	//std::shared_ptr<A[]> sp1(new A[10]);
	hang::shared_ptr<A> sp1(new A[10], [](A* ptr) {delete[] ptr; });
	hang::shared_ptr<int> sp2((int*)malloc(4), FreeFunc<int>());
	hang::shared_ptr<FILE> sp3(fopen("test.txt", "w"), [](FILE* ptr) {fclose(ptr); });

	hang::shared_ptr<A> sp4(new A);

	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中的实现的。

总结

智能指针作为C++资源管理的利器，其核心在于RAII机制------通过对象的构造与析构自动化管理资源。本文详细分析了以下内容：

智能指针的必要性：通过传统指针的内存泄漏问题，引出智能指针在异常安全与资源释放中的优势。

RAII与基础实现 ：以SmartPtr为例，展示了如何通过封装指针与重载运算符实现类指针行为。

主流智能指针：

  1. auto_ptr因其管理权转移的设计缺陷，已被现代C++弃用；
  2. unique_ptr通过禁止拷贝提供独占式资源管理，简单高效；
  3. shared_ptr基于引用计数支持共享资源，但需注意线程安全与循环引用问题；
  4. weak_ptr作为shared_ptr的辅助，解决了循环引用导致的内存泄漏。

高级话题：包括自定义删除器、线程安全实践，以及智能指针在C++11与Boost库中的演进关系。

智能指针虽强大，仍需开发者理解其原理与边界。例如，循环引用需结合weak_ptr规避，共享资源需关注线程安全，动态数组需匹配正确的删除器。在实际开发中，应根据场景选择最合适的智能指针类型，兼顾性能与安全性。通过本文的学习，希望读者能够熟练运用智能指针，编写出更健壮、更高效的C++代码，彻底告别手动内存管理的繁琐与风险。

相关推荐
桃子酱紫君20 分钟前
华为配置篇-BGP实验
开发语言·华为·php
QTX1873032 分钟前
JavaScript 中的原型链与继承
开发语言·javascript·原型模式
shaoing35 分钟前
MySQL 错误 报错：Table ‘performance_schema.session_variables’ Doesn’t Exist
java·开发语言·数据库
The Future is mine1 小时前
Python计算经纬度两点之间距离
开发语言·python
Enti7c1 小时前
HTML5和CSS3的一些特性
开发语言·css3
爱吃巧克力的程序媛1 小时前
在 Qt 创建项目时，Qt Quick Application (Compat) 和 Qt Quick Application
开发语言·qt
云 无 心 以 出 岫2 小时前
贪心算法QwQ
数据结构·c++·算法·贪心算法
独好紫罗兰2 小时前
洛谷题单3-P5719 【深基4.例3】分类平均-python-流程图重构
开发语言·python·算法
换一颗红豆2 小时前
【C++ 多态】—— 礼器九鼎，釉下乾坤，多态中的 “风水寻龙诀“
c++
篝火悟者2 小时前
自学-C语言-基础-数组、函数、指针、结构体和共同体、文件
c语言·开发语言
热门推荐
01我决定放弃搞 Java 了02DeepSeek各版本说明与优缺点分析03如何在WPS和Word/Excel中直接使用DeepSeek功能04RAG 实践- Ollama+RagFlow 部署本地知识库05苍穹外卖面试总结06从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑07本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程08DeepSeek R1本地化部署 Ollama + Chatbox 打造最强 AI 工具09如何本地部署AI智能体平台，带你手搓一个AI Agent10Android下HWC以及drm_hwcomposer普法(上)