【C++】智能指针

前言

一、为什么需要智能指针

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

2.1 RAII

2.2 智能指针的原理

2.3 std::auto_ptr

2.4 std::unique_ptr

2.5 std::shared_ptr

2.5.1 std::shared_ptr的原理

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

2.5.3 循环引用和std::weak_ptr

2.5.4 自定义删除器

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

总结

前言

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

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

一、为什么需要智能指针

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

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博客

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

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类来解决上面问题：

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模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。

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

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

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

2.3 std::auto_ptr

auto_ptr文档

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

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

// 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来了解它的原理

// 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对象之间共享资源。

shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

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改大一些概率就变大了，就容易出现了。最好也把自定义删除器那些代码去掉，不然程序会一直崩溃，因为线程不安全的程序会出现各种意外的情况。

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

2.5.3 循环引用和std::weak_ptr

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

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

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出来的对象在程序结束后，并没有调用析构函数，因为这里出现了循环引用。

循环引用分析：

node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
也就是说_next析构了，node2就释放了。
也就是说_prev析构了，node1就释放了。
但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

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

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

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实现：

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也有删除器）

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中智能指针的关系

C++ 98 中产生了第一个智能指针auto_ptr.
C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

总结

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

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

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

主流智能指针：

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

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

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