C++之智能指针

用户11991900

发布于 2026-01-15 12:12:12

一、智能指针使用场景

在 C++ 的发展历程中，裸指针一直是核心概念之一。它提供了对内存的直接访问和控制，但同时也带来了诸多隐患。例如，程序员可能忘记释放分配的内存，导致内存泄漏；或者在释放内存后，仍然试图通过已释放的指针访问资源，引发悬空指针问题。这些问题在大型项目中尤为常见，且难以排查和修复。

来看看以下代码：

void Func()
{
	// 这里可以看到如果发生除0错误抛出异常，另外下面的array和array2没有得到释放。
	// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再重新抛出去。
	// 但是如果array2new的时候抛异常呢，就还需要套一层捕获释放逻辑，这里更好解决方案
	// 是智能指针，否则代码太戳了
	int* array1 = new int[10];
	// try
	int* array2 = new int[10]; // 抛异常呢
	try
	{
		int len, time;
		cin >> len >> time;
		cout << Divide(len, time) << endl;
	}
	catch (...)
	{
		cout << "delete []" << array1 << endl;
		cout << "delete []" << array2 << endl;

		delete[] array1;
		delete[] array2;
		throw; // 异常重新抛出，捕获到什么抛出什么
	}
	// ...
	cout << "delete []" << array1 << endl;
	delete[] array1;
	cout << "delete []" << array2 << endl;
	delete[] array2;
}

int main()
{
	try

	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

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

RAII和智能指针的设计思路

RAII是Resource Acquisition Is Initialization的缩写，他是⼀种管理资源的类的设计思想，本质是⼀种利⽤对象⽣命周期来管理获取到的动态资源，避免资源泄漏，这⾥的资源可以是内存、⽂件指针、⽹络连接、互斥锁等等。RAII在获取资源时把资源委托给⼀个对象，接着控制对资源的访问，资源在对象的⽣命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题。
智能指针类除了满⾜RAII的设计思路，还要⽅便资源的访问，所以智能指针类还会想迭代器类⼀样，重载 operator*/operator->/operator[] 等运算符，⽅便访问资源。

template<class T>

class SmartPtr

{

public:
 // RAII

 SmartPtr(T* ptr)
 :_ptr(ptr)
 {}
 ~SmartPtr()
 {
 cout << "delete[] " << _ptr << endl;
 delete[] _ptr;
 }
 // 重载运算符，模拟指针的⾏为，⽅便访问资源 
 T& operator*()
 {
 return *_ptr;
 }
 T* operator->()
 {
 return _ptr;
 }
 T& operator[](size_t i)
 {
 return _ptr[i];
 }

private:
 T* _ptr;
};

RAII机制通过构造函数和析构函数来管理资源的分配和释放，确保资源在对象生命周期结束时能够被正确释放，这是RAII的核心思想，能够有效避免内存泄漏问题。
运算符重载通过重载*、->和[]运算符，使得SmartPtr能够像普通指针一样使用，方便访问资源。

二、智能指针的常见类型及原理

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

（一）std::unique_ptr

std::unique_ptr 是一种独占所有权的智能指针。它表示对资源的独占访问，即同一时间只能有一个 unique_ptr 指向某个资源。它的原理基于 RAII（Resource Acquisition Is Initialization）机制，即资源的获取即初始化。当 unique_ptr 被创建时，它会通过 new 操作符分配资源，并在 unique_ptr 被销毁时（如超出作用域或被重新赋值），自动调用 delete 释放资源。

{
    std::unique_ptr<int> ptr(new int(10));
    // 使用 ptr
} // 当超出作用域时，ptr 自动释放分配的内存

unique_ptr 不支持拷贝构造和拷贝赋值操作，因为这会违反独占所有权的原则。但它支持移动语义，可以通过 std::move 将资源的所有权从一个 unique_ptr 转移到另一个。

（二）std::shared_ptr

与 unique_ptr 不同，std::shared_ptr 允许多个指针共享对同一资源的所有权。它的原理是通过引用计数来管理资源的生命周期。每个 shared_ptr 都关联一个引用计数器，当一个新的 shared_ptr 通过拷贝构造或赋值操作指向同一资源时，引用计数加一；当某个 shared_ptr 被销毁或被重新赋值时，引用计数减一。当引用计数降为零时，表示没有 shared_ptr 再指向该资源，此时会自动释放资源。

std::shared_ptr<int> ptr1(new int(20));
std::shared_ptr<int> ptr2 = ptr1; // 引用计数加一
{
    std::shared_ptr<int> ptr3 = ptr2; // 引用计数再次加一
} // ptr3 超出作用域，引用计数减一
// 当 ptr1 和 ptr2 也超出作用域或被重新赋值后，引用计数降为零，资源被释放

shared_ptr 支持拷贝构造和拷贝赋值操作，这使得它在需要共享资源的场景中非常方便。但需要注意的是，引用计数的维护会带来一定的性能开销，尤其是在多线程环境下，因为需要对引用计数进行线程安全的操作。

（三）std::weak_ptr

std::weak_ptr 是一种弱引用智能指针，它通常与 shared_ptr 配合使用。weak_ptr 的作用是允许一个对象安全地引用另一个对象，但不增加引用计数。这在某些场景下非常有用，例如避免循环引用导致的内存泄漏。当一个 weak_ptr 被解引用时，它会检查被引用的对象是否仍然存在，如果存在，则返回一个 shared_ptr；如果不存在，则抛出异常或返回空指针。

std::shared_ptr<int> sharedPtr(new int(30));
std::weak_ptr<int> weakPtr = sharedPtr;

{
    std::shared_ptr<int> tempPtr = weakPtr.lock(); // 解引用 weakPtr
    if (tempPtr) {
        // 使用 tempPtr
    } else {
        // 被引用的对象已不存在
    }
}

(四)智能指针特性

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

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

2.shared_ptr 和 unique_ptr 都⽀持了operator bool的类型转换，
如果智能指针对象是⼀个空对象没有管理资源，
则返回false，否则返回true，意味着我们可以直接把智能指针对象给if判断是否为空。
// operator bool()
//	//if (up1.operator bool())
//	if (up1)
//	{
//		cout << "up1 不为空" << endl;
//	}
//	else
//	{
//		cout << "up1 为空" << endl;
//	}
//

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

删除器

智能指针的删除器（Deleter）是一个可调用对象，其作用是自定义智能指针在释放资源时的行为。通过使用删除器，我们可以灵活地控制资源的释放方式，这在处理非传统内存资源（如文件句柄、网络连接、GPU 内存等）时尤为重要。

删除器的声明与使用

删除器是一个可调用对象，它可以是：

函数指针
函数对象（Functor）
Lambda 表达式
成员函数指针

在这里演示仿函数类型构造的对象和lambda

class Fclose
{
public:
	void operator()(FILE* ptr)
	{
		cout << "fclose:" << ptr << endl;
		fclose(ptr);
	}
};

// 定制删除器
int main()
{
	// 定制删除方式，最好用shared_ptr，其次就是最好用lambda做删除器
	//
	std::shared_ptr<FILE> sp1(fopen("Test.cpp", "r"), Fclose());
	std::shared_ptr<FILE> sp2(fopen("Test.cpp", "r"), [](FILE* fp) {
		cout << "fclose:" << fp << endl;
		fclose(fp);
	});
	std::unique_ptr<FILE, Fclose> up1(fopen("Test.cpp", "r"));

	auto FcloseFunc = [](FILE* fp) {
		cout << "fclose:" << fp << endl;
		fclose(fp);
	};
	std::unique_ptr<FILE, decltype(FcloseFunc)> up3(fopen("Test.cpp", "r"), FcloseFunc);


	return 0;
}

（五）shared_ptr原理

shared_ptr，引⽤计数的设计，主要这⾥⼀份资源就需要⼀个引⽤计数，所以引⽤计数才⽤静态成员的⽅式是⽆法实现的，要使⽤堆上动态开辟的⽅式，构造智能指针对象时来⼀份资源，就要new⼀个引⽤计数出来。多个shared_ptr指向资源时就++引⽤计数，shared_ptr对象析构时就–引⽤计数，引⽤计数减到0时代表当前析构的shared_ptr是最后⼀个管理资源的对象，则析构资源。

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

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

		// sp2(sp1)
		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;
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

		// ָһʹ
		T& operator*()
		{
			return *_ptr;
		}

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

		T* get()
		{
			return _ptr;
		}

		int use_count()
		{
			return *_pcount;
		}

		operator bool()
		{
			return _ptr != nullptr;
		}
	private:
		T* _ptr;
		int* _pcount;


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

三.shared_ptr循环引⽤问题

shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会导致资源没得到释放内存泄漏。

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

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

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

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

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访问资源是安全的。