解析 C++ 智能指针的核心原理与使用。基于 RAII 思想，介绍 unique_ptr、shared_ptr、weak_ptr 等标准库实现及自定义删除器。涵盖循环引用、线程安全等常见问题解决方案，并提供最佳实践建议，帮助开发者避免内存泄漏，提升代码安全性。
在 C++ 编程中，内存管理始终是核心挑战之一。手动使用 new 分配内存后，若因异常、逻辑疏忽等原因未执行 ，就会导致内存泄漏。智能指针作为 C++ 的核心工具，通过 RAII（资源获取即初始化）思想自动管理资源，完美解决了这一痛点。本文将从使用场景、设计原理、标准库实现、常见问题等方面，全面解析智能指针的技术细节。
delete手动管理动态内存时，异常场景下的资源释放问题尤为突出。看下面的示例代码：
double Divide(int a, int b) {
if (b == 0) throw "Divide by zero condition!";
return (double)a / (double)b;
}
void Func() {
int* array1 = new int[10];
int* array2 = new int[10];
// 若此处抛异常，array1 未释放
try {
int len, time;
cin >> len >> time;
cout << Divide(len, time) << endl;
} catch (...) {
delete[] array1; // 捕获异常时释放
delete[] array2;
throw;
}
delete[] array1;
delete[] array2;
}
上述代码存在两个问题：一是 array2 初始化时若抛异常，array1 会泄漏；二是嵌套异常处理导致代码冗余。而智能指针能自动管理资源生命周期，无论正常执行还是异常退出，都会在对象析构时释放资源，让代码更简洁、安全。
RAII（Resource Acquisition Is Initialization）即'资源获取即初始化'，是一种通过对象生命周期管理资源的设计思想。其核心逻辑如下：
基于 RAII 思想，我们可以实现一个简单的智能指针，重载指针操作符以模拟原生指针行为：
template<class T>
class SmartPtr {
public:
// 构造时获取资源
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; // 管理的资源指针
};
使用该智能指针重构 Func 函数，代码将大幅简化：
void Func() {
SmartPtr<int> sp1 = new int[10];
SmartPtr<int> sp2 = new int[10];
for (size_t i = 0; i < 10; i++) {
sp1[i] = sp2[i] = i;
}
int len, time;
cin >> len >> time;
cout << Divide(len, time) << endl;
}
无论是否抛出异常，sp1和sp2析构时都会自动释放数组，彻底避免内存泄漏。
C++ 标准库在 <memory> 头文件中提供了 4 种智能指针，各自适用于不同场景，核心差异在于资源所有权管理策略。
示例：
auto_ptr<Date> ap1(new Date);
auto_ptr<Date> ap2(ap1); // ap1 已悬空，后续访问 ap1->_year 会崩溃
= delete）；std::move），移动后原对象悬空；new[] 资源（unique_ptr<Date[]> up(new Date[5])）；示例：
unique_ptr<Date> up1(new Date);
// unique_ptr<Date> up2(up1); // 编译报错，不支持拷贝
unique_ptr<Date> up3(move(up1)); // 支持移动，up1 悬空
make_shared 构造（更高效，避免内存碎片）；new 分配的资源）；new[] 资源；示例：
shared_ptr<Date> sp1(new Date);
shared_ptr<Date> sp2(sp1); // 拷贝，计数=2
shared_ptr<Date> sp3 = make_shared<Date>(2024, 9, 11); // 推荐构造方式
cout << sp1.use_count() << endl; // 输出 2
shared_ptr 的循环引用问题；shared_ptr 时不增加引用计数；operator* 和 operator->，需通过 lock() 获取 shared_ptr 访问资源；expired() 检查资源是否已释放；示例：
shared_ptr<string> sp1 = make_shared<string>("hello");
weak_ptr<string> wp = sp1; // 计数仍为 1
if (!wp.expired()) {
shared_ptr<string> sp2 = wp.lock(); // 计数 +1
cout << *sp2 << endl;
}
智能指针默认使用 delete 释放资源，若资源通过 new[]、fopen 等方式获取，需自定义删除器：
// 1. 仿函数删除器（释放 new[] 资源）
template<class T> class DeleteArray {
public:
void operator()(T* ptr) { delete[] ptr; }
};
// 2. lambda 删除器（释放文件句柄）
shared_ptr<FILE> sp5(fopen("test.cpp", "r"), [](FILE* ptr) { fclose(ptr); });
// 使用示例
shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());
unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
template<class T>
class unique_ptr {
public:
explicit unique_ptr(T* ptr = nullptr) : _ptr(ptr) {}
// 移动构造
unique_ptr(unique_ptr<T>&& sp) : _ptr(sp._ptr) { sp._ptr = nullptr; }
~unique_ptr() { if (_ptr) delete _ptr; }
// 禁用拷贝构造和赋值
unique_ptr(const unique_ptr<T>&) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;
// 指针操作符重载
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
private:
T* _ptr;
};
template<class T>
class shared_ptr {
public:
explicit shared_ptr(T* ptr = nullptr) : _ptr(ptr), _pcount(new int(1)) {}
// 拷贝构造：计数 +1
shared_ptr(const shared_ptr<T>& sp) : _ptr(sp._ptr), _pcount(sp._pcount) { ++(*_pcount); }
// 析构：计数 -1，为 0 则释放资源
~shared_ptr() { if (--(*_pcount) == 0) { delete _ptr; delete _pcount; } }
// 指针操作符重载
T& operator*() { return *_ptr; }
T* operator->() { return _ptr; }
// 获取引用计数
int use_count() const { return *_pcount; }
private:
T* _ptr; // 管理的资源
int* _pcount; // 引用计数（堆上分配）
function<void(T*)> _del = [](T* p) { delete p; }; // 默认删除器
};
两个 shared_ptr 相互引用，导致引用计数无法归零，资源泄漏：
struct ListNode {
int _data;
shared_ptr<ListNode> _next; // 相互引用
shared_ptr<ListNode> _prev;
~ListNode() { cout << "~ListNode()" << endl; }
};
int main() {
shared_ptr<ListNode> n1(new ListNode);
shared_ptr<ListNode> n2(new ListNode);
n1->_next = n2; // n2 计数=2
n2->_prev = n1; // n1 计数=2
// 析构时 n1 和 n2 计数均变为 1，资源无法释放
return 0;
}
将相互引用的成员改为 weak_ptr（不增加引用计数）：
struct ListNode {
int _data;
weak_ptr<ListNode> _next; // 弱引用，不影响计数
weak_ptr<ListNode> _prev;
~ListNode() { cout << "~ListNode()" << endl; }
};
shared_ptr 会导致计数错乱；shared_ptr 指向的对象本身线程不安全，需手动加锁保护。atomic<int>*）或加锁；mutex）保护。unique_ptr 和 auto_ptr 移动后，原对象悬空，禁止后续访问；weak_ptr 需通过 expired() 检查资源状态，再通过 lock() 获取 shared_ptr 访问。unique_ptr 效率最高（无引用计数开销）；make_shared 构造（比直接 new 更高效）；weak_ptr；new 分配的资源（如 new[]、文件句柄）必须指定删除器；shared_ptr 和 unique_ptr 的构造函数用 explicit 修饰，避免普通指针隐式转换；new/delete，从源头避免内存泄漏。智能指针是 C++ 内存管理的核心工具，其本质是 RAII 思想的实现。unique_ptr 和 shared_ptr 覆盖了绝大多数场景，weak_ptr 则解决了 shared_ptr 的循环引用问题。掌握智能指针的使用场景、原理和避坑要点，能大幅提升代码的安全性和可维护性。在实际开发中，应优先使用标准库智能指针，避免手动管理动态内存，从根本上杜绝内存泄漏。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML转Markdown 互为补充。 在线工具，Markdown转HTML在线工具，online
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。 在线工具，HTML转Markdown在线工具，online
通过删除不必要的空白来缩小和压缩JSON。 在线工具，JSON 压缩在线工具，online