内存管理与智能指针
用智能指针消除内存泄漏与悬垂指针
#栈与堆:两种内存,两种命运
C++ 程序用到的内存大致分两块,理解它们的差别是理解 C++ 内存管理的起点。
栈(stack)是一块连续的小内存(Linux 默认 8 MB),由编译器自动管理。函数调用时把局部变量"压栈",函数返回时整块弹出。分配和释放只是移动一个栈指针寄存器,速度极快,且时机完全确定。
堆(heap)(也叫自由存储区)是一大块进程内存,由程序员手动申请和释放,生命周期可以跨越函数调用。代价是分配慢(要找空闲块、可能触发系统调用)、必须手动管理、容易产生内存碎片。
其他语言把这块差异藏起来了:Java 里所有对象都在堆上(基本类型在栈帧里),由 GC 统一回收;Python 里"一切皆对象",全在堆上,靠引用计数 + 分代 GC;JS 引擎同理。C++ 的特别之处在于栈对象是默认选项,且生命周期与作用域严格绑定——这正是第 5 章 RAII 得以成立的原因。
#include <iostream>
#include <memory>
#include <string>
struct Point {
int x, y;
};
// 返回堆对象:调用方负责释放(不推荐这样写,后面会用智能指针改写)
Point* make_on_heap(int x, int y) {
return new Point{x, y}; // 堆分配,函数返回后依然有效
}
// 返回栈对象:安全,值语义
Point make_on_stack(int x, int y) {
return Point{x, y}; // 复制/移动出去,无需手动管理
}
int main() {
// 1) 栈对象:离开作用域自动销毁,无需任何手动操作
Point stack_pt{1, 2};
std::cout << "栈对象: " << stack_pt.x << "," << stack_pt.y << "\n";
// 2) 堆对象:用 new 申请,返回指针
Point* heap_pt = new Point{3, 4};
std::cout << "堆对象: " << heap_pt->x << "," << heap_pt->y << "\n";
delete heap_pt; // 必须手动释放,且只能释放一次
heap_pt = nullptr; // 释放后置空是好习惯,避免误用
// 3) 数组形式:new[] 必须配 delete[],混用是未定义行为
int* arr = new int[10]{};
arr[0] = 42;
delete[] arr;
// 4) 栈上数组:大小必须是编译期常量(或编译器扩展 VLA,不推荐)
int fixed[5]{1, 2, 3, 4, 5};
std::cout << "栈数组首元素: " << fixed[0] << "\n";
// 5) 值语义返回,无需关心内存
Point p = make_on_stack(5, 6);
std::cout << "值返回: " << p.x << "\n";
// 6) 堆返回必须记得 delete,否则泄漏
Point* q = make_on_heap(7, 8);
std::cout << "堆返回: " << q->x << "\n";
delete q;
std::cout << "栈空间通常远小于堆,别在栈上开大数组\n";
return 0;
}经验法则:默认用栈对象;只有需要"生命周期跨作用域"、"大小运行时才确定且很大"、"多态(通过基类指针操作派生类对象)"这几种情况才用堆。
#new/delete 的三大灾难
手动管理堆内存有三个经典错误,它们是 C++ 早期被称为"内存地狱"的原因:
- 内存泄漏:
new之后忘了delete,内存永远不归还。长时间运行的程序(服务器、GUI 应用)会逐渐吃光内存。 - 悬垂指针(dangling pointer):
delete之后指针还留着,指向已释放的内存。再访问它是未定义行为——可能读到垃圾,也可能"看起来正常"从而埋下更深的隐患。 - 双重释放(double free):同一块内存
delete两次,堆管理器直接崩溃。
Java/Python/JS 程序员很少遇到这些,因为 GC 保证"只要还被引用就不会回收"。但 GC 也有代价:不可预测的停顿(STW)、更高的内存占用、无法精确控制释放时机(文件句柄、锁这类资源不能等 GC)。C++ 的答案是:不引入 GC,而是用智能指针把 delete 自动化。
#include <iostream>
#include <memory>
#include <stdexcept>
class Resource {
public:
explicit Resource(int id) : id_(id) {
std::cout << "Resource " << id_ << " 构造\n";
}
~Resource() {
std::cout << "Resource " << id_ << " 析构\n";
}
void use() { std::cout << "使用 Resource " << id_ << "\n"; }
private:
int id_;
};
void leak_demo() {
Resource* r = new Resource(1);
r->use();
// 忘了 delete —— 内存泄漏,析构函数永远不会被调用
}
void dangling_demo() {
Resource* r = new Resource(2);
delete r;
// r 现在是悬垂指针,指向已释放的内存
// r->use(); // 未定义行为!可能崩溃,也可能"侥幸"不崩
r = nullptr; // 释放后立即置空是唯一的自救办法
if (r != nullptr) {
r->use();
}
}
void early_return_bug(int mode) {
Resource* r = new Resource(3);
if (mode == 0) {
return; // 提前返回,delete 被跳过 —— 泄漏
}
r->use();
delete r;
}
// 用智能指针重写上面的函数:无论怎么返回、是否抛异常,资源都会被释放
void safe_version(int mode) {
auto r = std::make_unique<Resource>(4);
if (mode == 0) {
return; // 安全:r 析构,Resource 被自动释放
}
r->use();
if (mode == 1) {
throw std::runtime_error("出错了"); // 同样安全:栈展开时析构
}
r->use();
}
int main() {
leak_demo();
dangling_demo();
early_return_bug(0);
try {
safe_version(1);
} catch (const std::exception& e) {
std::cout << "捕获: " << e.what() << "\n";
}
std::cout << "程序结束\n";
return 0;
}这段代码需要 #include <stdexcept>。注意 safe_version 里无论走哪条路径,Resource 的析构都会执行——这就是 RAII + 智能指针的威力。
#unique_ptr:独占所有权
std::unique_ptr<T> 表达独占所有权:同一时刻只有一个 unique_ptr 拥有这块内存。它不可拷贝(拷贝构造被 = delete),只能移动——这就从类型系统层面杜绝了双重释放。
它的运行时开销为零:sizeof(unique_ptr<T>) == sizeof(T*),析构就是一句 delete。这是 C++ "零开销抽象"理念的典范。
优先用 std::make_unique<T>(args...)(C++14 起)而不是 new:异常安全(避免 f(unique_ptr(new T), may_throw()) 这种参数求值顺序导致的泄漏),且代码更短。
#include <iostream>
#include <memory>
#include <string>
#include <vector>
class Task {
public:
explicit Task(std::string name) : name_(std::move(name)) {
std::cout << "创建任务 " << name_ << "\n";
}
~Task() { std::cout << "销毁任务 " << name_ << "\n"; }
void run() const { std::cout << "执行 " << name_ << "\n"; }
private:
std::string name_;
};
// 工厂函数:把所有权交给调用方,返回 unique_ptr 是最清晰的表达
std::unique_ptr<Task> create_task(const std::string& name) {
return std::make_unique<Task>(name);
}
// 需要"借用"对象但不取得所有权时,传裸指针或引用 —— 不要传 unique_ptr
void run_borrowed(const Task* t) {
if (t != nullptr) {
t->run();
}
}
int main() {
// 创建:始终用 make_unique
auto t1 = std::make_unique<Task>("编译");
t1->run(); // 用法和裸指针一致:-> 和 *
std::cout << "对象地址: " << t1.get() << "\n";
// 独占语义:拷贝被禁止,下面这行编译不过
// std::unique_ptr<Task> t2 = t1;
// 转移所有权:必须显式 std::move,转移后 t1 变为空
std::unique_ptr<Task> t2 = std::move(t1);
std::cout << "t1 是否为空: " << std::boolalpha << (t1 == nullptr) << "\n";
t2->run();
// 主动释放:reset() 会立即析构对象
t2.reset();
std::cout << "t2 已释放\n";
// 放弃所有权:release() 返回裸指针且不 delete,交由别人(或 C API)管理
auto t3 = create_task("打包");
Task* raw = t3.release(); // t3 变空,raw 需要手动 delete
delete raw;
// 放进容器:unique_ptr 可以安全存入 vector(可移动)
std::vector<std::unique_ptr<Task>> tasks;
tasks.push_back(create_task("下载"));
tasks.push_back(create_task("安装"));
tasks.emplace_back(std::make_unique<Task>("清理"));
for (const auto& t : tasks) {
run_borrowed(t.get()); // 借用时传 get()
}
// 自定义删除器:管理非 new/delete 的资源(这里是数组)
auto arr = std::make_unique<int[]>(5);
arr[0] = 42;
std::cout << "数组首元素 " << arr[0] << "\n";
return 0; // 所有 unique_ptr 自动释放
}unique_ptr 应该是你的默认选择。Qt 世界里对应的是 QScopedPointer 和 Qt 的父子对象树机制,思路一致。
#shared_ptr 与 weak_ptr:共享所有权
std::shared_ptr<T> 表达共享所有权:多个指针共同拥有同一对象,内部维护引用计数,计数归零时自动释放。
如果你写过 Python,会觉得这很眼熟——CPython 的主力内存管理机制就是引用计数,shared_ptr 几乎是同一套东西。但有两个关键差别:一是 C++ 的 shared_ptr 计数是原子操作(线程安全,也因此稍慢);二是 Python 有循环垃圾回收器兜底,而 shared_ptr 没有——两个互相持有的 shared_ptr 会永远泄漏。
shared_ptr 的开销也要心里有数:每个对象额外需要一个控制块(引用计数、弱计数、删除器),sizeof(shared_ptr<T>) == 2 * sizeof(T*)。不要为了"省事"到处用 shared_ptr,能用 unique_ptr 或栈对象就别用。
#include <iostream>
#include <memory>
#include <string>
struct Node {
std::string name;
// std::shared_ptr<Node> parent; // 如果这里是 shared_ptr,就会形成循环引用
std::weak_ptr<Node> parent; // 用 weak_ptr 打破循环
std::shared_ptr<Node> child;
explicit Node(std::string n) : name(std::move(n)) {
std::cout << "Node " << name << " 构造\n";
}
~Node() { std::cout << "Node " << name << " 析构\n"; }
};
// 循环引用演示:两个对象互相持有 shared_ptr,谁也释放不了
void cycle_demo() {
struct A { std::shared_ptr<A> other; ~A() { std::cout << "A 析构\n"; } };
auto x = std::make_shared<A>();
auto y = std::make_shared<A>();
x->other = y;
y->other = x;
std::cout << "离开 cycle_demo,x 和 y 都不会被析构(泄漏)\n";
}
int main() {
// make_shared:一次分配同时搞定对象和控制块,比 shared_ptr<T>(new T) 更快更安全
auto root = std::make_shared<Node>("root");
std::cout << "引用计数 = " << root.use_count() << "\n"; // 1
{
auto alias = root; // 计数 +1
std::cout << "引用计数 = " << root.use_count() << "\n"; // 2
} // alias 析构,计数回到 1
std::cout << "引用计数 = " << root.use_count() << "\n"; // 1
// 建立父子关系:父 → 子用 shared_ptr,子 → 父用 weak_ptr
auto leaf = std::make_shared<Node>("leaf");
root->child = leaf;
leaf->parent = root; // weak_ptr 不增加引用计数
std::cout << "root 计数 = " << root.use_count() << "(weak 不计数)\n";
// 使用 weak_ptr:必须先 lock() 升级为 shared_ptr,判断对象是否还活着
if (auto p = leaf->parent.lock()) {
std::cout << "leaf 的父节点是 " << p->name << "\n";
} else {
std::cout << "父节点已被释放\n";
}
// weak_ptr 的经典用途:打破缓存、观察者列表、父子双向引用
std::weak_ptr<Node> observer = root;
root.reset(); // 释放 root
if (observer.expired()) { // expired() 等价于 use_count() == 0
std::cout << "被观察对象已销毁\n";
}
cycle_demo();
std::cout << "程序结束\n";
return 0;
}#智能指针选型速查
| 场景 | 选择 | 说明 |
|---|---|---|
| 默认情况 | 栈对象 | 最快、最安全,无需指针 |
| 需要动态分配、独占 | std::unique_ptr<T> | 零开销,可移动不可拷贝 |
| 需要共享所有权 | std::shared_ptr<T> | 引用计数,注意循环引用 |
| 只想观察、不拥有 | 裸指针 T* 或引用 T& | 前提是你确定对象活得更久 |
| 观察可能已销毁的共享对象 | std::weak_ptr<T> | 需先 lock() |
| Qt 中的 QObject 子类 | Qt 父子对象树 | 父对象析构时自动删除子对象 |
几条工程经验:永远用 make_unique / make_shared 而不是裸 new;函数参数如果需要"借用",用裸指针或引用而不是智能指针(传 const std::unique_ptr<T>& 是个常见反模式,它把所有权策略硬编码进了接口);shared_ptr 是设计上的一个信号,意味着"这个对象的生命周期需要多方共同决定",如果只是懒得想生命周期,那多半该用 unique_ptr。
#include <cstdio>
#include <iostream>
#include <memory>
#include <string>
// 自定义删除器:智能指针不只管内存,可以管任何"获取/释放"成对的资源
using FilePtr = std::unique_ptr<std::FILE, int (*)(std::FILE*)>;
FilePtr open_file(const std::string& path, const char* mode) {
std::FILE* f = std::fopen(path.c_str(), mode);
if (f == nullptr) {
return FilePtr(nullptr, &std::fclose);
}
return FilePtr(f, &std::fclose); // 析构时自动调用 fclose
}
// 接口设计:借用就传引用,不要传智能指针
void process(const std::string& tag, int value) {
std::cout << tag << ": " << value << "\n";
}
int main() {
{
auto f = open_file("log.txt", "w");
if (f) {
std::fprintf(f.get(), "hello\n");
}
} // 自动 fclose,即使中途抛异常也一样
// 接口示例:所有权在调用方,函数只是用一下
auto data = std::make_unique<int>(42);
process("值", *data); // 传引用,不移交所有权
// shared_ptr 的别名构造:让子对象和父对象共享同一个控制块
struct Header { int version{1}; };
struct Packet { Header header; int payload{0}; };
auto packet = std::make_shared<Packet>();
std::shared_ptr<Header> header(packet, &packet->header);
std::cout << "packet 计数 = " << packet.use_count()
<< ",header 版本 = " << header->version << "\n";
return 0;
}#小结
- 栈对象由编译器管理、生命周期确定、速度最快;堆对象需手动管理但可跨作用域。默认用栈,需要多态或大对象时才用堆。
- 裸
new/delete的三大灾难是内存泄漏、悬垂指针、双重释放;delete后应立即把指针置空。 std::unique_ptr表达独占所有权,零开销(大小等于裸指针),不可拷贝只能移动,是动态分配的默认选择;始终用make_unique创建。std::shared_ptr用引用计数实现共享所有权,思路与 Python 的引用计数类似,但没有循环垃圾回收器兜底,互相持有会导致泄漏。std::weak_ptr不增加引用计数,用于打破循环引用和观察可能已销毁的对象;使用前必须lock()升级。- 智能指针能管的不止内存:配合自定义删除器可以管理文件句柄、socket、锁等任何成对资源。
#练习
- 写一个函数,用
new分配一个 1000 元素的int数组,在中间return前故意不delete,用循环调用 10000 次并观察内存占用(macOS 用活动监视器,Linux 用top)。然后用std::unique_ptr<int[]>重写,对比结果。 - 实现
struct TreeNode { std::string name; std::vector<std::unique_ptr<TreeNode>> children; TreeNode* parent; },写一个add_child函数和一个print递归打印函数。思考为什么子节点用unique_ptr、父节点用裸指针。 - 构造一个循环引用:两个
struct互相持有shared_ptr,运行后观察析构函数是否被调用。然后把其中一个改成weak_ptr,验证泄漏消失。 - 用
unique_ptr+ 自定义删除器包装std::FILE*(参考最后一节),再包装一个int*数组删除器[](int* p){ delete[] p; },体会删除器的通用性。最后把练习 2 的树改成shared_ptr版本,讨论什么业务场景下共享所有权才是合理的。