C++
C++ 内存管理：从裸指针到智能指针的进化
C++ 内存管理常面临内存泄漏、野指针及二次释放等问题。智能指针基于 RAII 机制实现资源自动管理。unique_ptr 独占所有权，高效安全；shared_ptr 通过引用计数共享所有权，但需注意循环引用；weak_ptr 作为弱引用打破循环并观察对象生命周期。文章详解三者原理、使用场景、定制删除器及性能优化策略，提供避免常见错误的最佳实践，帮助开发者构建更健壮的 C++ 程序。
C++ 内存管理常面临内存泄漏、野指针及二次释放等问题。智能指针基于 RAII 机制实现资源自动管理。unique_ptr 独占所有权，高效安全；shared_ptr 通过引用计数共享所有权，但需注意循环引用；weak_ptr 作为弱引用打破循环并观察对象生命周期。文章详解三者原理、使用场景、定制删除器及性能优化策略，提供避免常见错误的最佳实践，帮助开发者构建更健壮的 C++ 程序。
在 C++ 的世界里，指针赋予了开发者直接操作内存的强大能力，但也埋下了内存泄漏、野指针、二次释放等一系列风险。幸运的是，C++ 标准库提供了智能指针作为解决方案，它通过 RAII（资源获取即初始化）机制，让内存管理变得安全、高效且省心。本文将从底层原理到实际应用，全方位拆解智能指针的设计精髓，带你掌握 unique_ptr、shared_ptr、weak_ptr 的使用技巧。
在深入智能指针之前，我们先回顾一下**裸指针（Raw Pointer）**存在的痛点。
内存泄漏是指程序分配的内存空间在使用完毕后，没有被正确释放，导致这部分内存永远无法被再次使用。
// 反面示例：裸指针导致的内存泄漏
void func() {
int* p = new int(10);
// 业务逻辑处理...
if (some_condition) {
return; // 提前返回，忘记释放 p
}
delete p;
}
在上述代码中，如果 some_condition 为 true，函数会提前返回，delete p 语句就永远不会执行，导致堆内存泄漏。
二次释放是指对同一块内存进行多次 delete 操作。这会破坏堆内存的完整性，导致程序崩溃或未定义行为。
// 反面示例：裸指针导致的二次释放
void func() {
int* p = new int(20);
delete p; // 第一次释放
// ... 中间经过复杂的逻辑，忘记 p 已经被释放
delete p; // 第二次释放，程序崩溃
}
野指针是指指向已释放内存或非法内存地址的指针。访问野指针会导致程序崩溃、数据损坏等不可预测的结果。
// 反面示例：裸指针导致的野指针问题
int* func() {
int x = 10;
return &x; // 返回栈内存地址，形成野指针
}
当程序发生异常时，正常的执行流程会被打断，可能导致裸指针无法被释放。
// 反面示例：异常导致的内存泄漏
void func() {
int* p = new int(30);
try {
throw runtime_error("something wrong");
} catch (...) {
throw; // 重新抛出异常，未处理 p 的释放
}
delete p; // 永远不会执行
}
面对裸指针的种种问题，智能指针的核心设计思想应运而生：将指针的生命周期管理与对象的生命周期绑定，通过 RAII 机制，实现内存的自动释放。
简单来说，智能指针是一个'包装器类'，它封装了裸指针，并在其析构函数中自动执行 delete 操作。
C++11 标准库提供了三种核心智能指针：unique_ptr、shared_ptr和weak_ptr。
unique_ptr是最简单、最高效的智能指针，它的核心特性是独占所有权。同一时间，只能有一个 unique_ptr 指向一块内存。
unique_ptr的底层实现非常简洁：
delete 或 delete[] 释放内存。#include <memory>
#include <iostream>
using namespace std;
class Test {
public:
Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
void show() { cout << "Test id: " << id_ << endl; }
private:
int id_;
};
void test_unique_ptr_basic() {
// 方式 1：通过 make_unique 创建（推荐）
unique_ptr<Test> up1 = make_unique<Test>(1);
up1->show();
// 方式 2：通过 new 创建（不推荐）
unique_ptr<Test> up2(new Test(2));
// 错误：不允许拷贝构造
// unique_ptr<Test> up3 = up1;
// 正确：移动构造（转移所有权）
unique_ptr<Test> up5 = move(up1);
up5->show();
// 重置指针
up5.reset(new Test(5));
}
unique_ptr。vector<unique_ptr<T>> 是常见用法。最佳实践：优先使用 make_unique 创建 unique_ptr，避免手动调用 get()、release()。
shared_ptr支持共享所有权，多个 shared_ptr 可以指向同一块内存，当最后一个 shared_ptr 被销毁时，内存才会被释放。
shared_ptr的核心机制是引用计数（Reference Counting）：
shared_ptr 都封装了一个'数据指针'和一个'控制块指针'；shared_ptr 指向对象时，引用计数加 1；
#include <memory>
#include <iostream>
using namespace std;
class Test {
public:
Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
void show() { cout << "Test id: " << id_ << endl; }
shared_ptr<Test> sp_self;
private:
int id_;
};
void test_shared_ptr_basic() {
shared_ptr<Test> sp1 = make_shared<Test>(1);
cout << "sp1 use_count: " << sp1.use_count() << endl; // 1
// 拷贝构造：引用计数加 1
shared_ptr<Test> sp2 = sp1;
cout << "sp1 use_count after copy: " << sp1.use_count() << endl; // 2
// 移动构造：引用计数不变
shared_ptr<Test> sp4 = move(sp1);
cout << "sp4 use_count after move: " << sp4.use_count() << endl; // 2
}
循环引用是指两个或多个 shared_ptr 互相持有对方的引用，导致它们的引用计数永远无法减为 0，从而造成内存泄漏。
为了解决循环引用问题，C++ 标准库引入了第三种智能指针 —— weak_ptr。
weak_ptr是一种'弱引用'智能指针，它的核心特性是不拥有对象的所有权，仅能观察 shared_ptr 所管理的对象。
weak_ptr仅存储控制块的指针，不存储数据指针；weak_ptr 时，会将控制块的弱引用计数加 1；weak_ptr无法直接访问对象，必须通过 lock() 方法获取一个 shared_ptr 才能访问对象；expired() 方法判断所观察的对象是否已被析构。#include <memory>
#include <iostream>
using namespace std;
class Test {
public:
Test(int id) : id_(id) { cout << "Test(" << id_ << ") 构造" << endl; }
~Test() { cout << "Test(" << id_ << ") 析构" << endl; }
void show() { cout << "Test id: " << id_ << endl; }
weak_ptr<Test> wp_self;
private:
int id_;
};
void test_weak_ptr_solve_cycle() {
shared_ptr<Test> sp1 = make_shared<Test>(100);
shared_ptr<Test> sp2 = make_shared<Test>(200);
// 用 weak_ptr 代替 shared_ptr，避免循环引用
sp1->wp_self = sp2;
sp2->wp_self = sp1;
cout << "sp1 use_count: " << sp1.use_count() << endl; // 1
cout << "sp2 use_count: " << sp2.use_count() << endl; // 1
// 通过 lock() 访问对方
if (auto sp = sp1->wp_self.lock()) {
cout << "sp1 access sp2: ";
sp->show();
}
}
weak_ptr。weak_ptr，避免主题被观察者'绑架'。weak_ptr，当对象被销毁时，缓存自动失效。默认情况下，智能指针会使用 delete 或 delete[] 释放内存。但在某些场景下，我们需要自定义释放逻辑。
#include <memory>
#include <iostream>
#include <fstream>
using namespace std;
void close_file(FILE* fp) {
if (fp) fclose(fp);
}
void test_custom_deleter_unique() {
FILE* fp = fopen("test.txt", "w");
unique_ptr<FILE, decltype(&close_file)> up2(fp, close_file);
}
void test_custom_deleter_shared() {
FILE* fp = fopen("test.txt", "w");
shared_ptr<FILE> sp2(fp, close_file);
}
C++ 标准库提供了专门的类型转换函数：
static_pointer_cast：对应 static_cast。dynamic_pointer_cast：对应 dynamic_cast。const_pointer_cast：对应 const_cast。#include <memory>
#include <iostream>
using namespace std;
class Base { public: virtual void show() {} virtual ~Base() {} };
class Derived : public Base { public: void show() override {} };
void test_pointer_cast() {
shared_ptr<Base> sp_base = make_shared<Derived>();
if (auto sp_derived = dynamic_pointer_cast<Derived>(sp_base)) {
sp_derived->show();
}
}
注意：dynamic_pointer_cast 仅对多态类型有效，unique_ptr不支持这些转换。
const& 传递。lock() 返回的 shared_ptr。expired() 或 lock() 返回的 shared_ptr 是否为空。delete 而非 delete[]。unique_ptr 禁用拷贝，强行拷贝会编译失败。weak_ptr。从裸指针的风险到智能指针的安全，C++ 的内存管理经历了一次革命性的进化。智能指针通过 RAII 机制，将内存管理的责任从开发者转移到编译器，从根本上解决了内存泄漏、二次释放、野指针等经典问题。在实际开发中，应遵循'能用智能指针就不用裸指针'的原则，合理选择合适的智能指针，让内存管理不再成为痛点。
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
将字符串编码和解码为其 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
将JSON字符串修饰为友好的可读格式。 在线工具，JSON美化和格式化在线工具，online