QC++ / Qt 学习之路

内存管理与智能指针

用智能指针消除内存泄漏与悬垂指针

进阶第 6 / 48 章第一篇 · C++ 基础巩固

#栈与堆:两种内存,两种命运

C++ 程序用到的内存大致分两块,理解它们的差别是理解 C++ 内存管理的起点。

进程内存布局(典型 32/64 位虚拟地址空间)自上而下依次降低地址,栈与堆相向生长高地址低地址高地址 → 低地址栈 Stack由高地址向低地址增长;存放局部变量、函数参数、返回地址;局部变量,自动回收堆 Heap运行时动态分配,空间最大;需要程序员配对管理生命周期;new / delete 手动管理全局区 Data + BSS全局变量、static 变量:已初始化放 data,未初始化放 bss;程序结束才释放代码区 Text存放编译后的机器指令与字符串字面量,通常只读且可共享;只读,指令区栈向下生长堆向上生长
进程内存布局:栈、堆、全局区与代码区

栈(stack)是一块连续的小内存(Linux 默认 8 MB),由编译器自动管理。函数调用时把局部变量"压栈",函数返回时整块弹出。分配和释放只是移动一个栈指针寄存器,速度极快,且时机完全确定。

堆(heap)(也叫自由存储区)是一大块进程内存,由程序员手动申请和释放,生命周期可以跨越函数调用。代价是分配慢(要找空闲块、可能触发系统调用)、必须手动管理、容易产生内存碎片。

其他语言把这块差异藏起来了:Java 里所有对象都在堆上(基本类型在栈帧里),由 GC 统一回收;Python 里"一切皆对象",全在堆上,靠引用计数 + 分代 GC;JS 引擎同理。C++ 的特别之处在于栈对象是默认选项,且生命周期与作用域严格绑定——这正是第 5 章 RAII 得以成立的原因。

C++
#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++ 早期被称为"内存地狱"的原因:

  1. 内存泄漏:new 之后忘了 delete,内存永远不归还。长时间运行的程序(服务器、GUI 应用)会逐渐吃光内存。
  2. 悬垂指针(dangling pointer):delete 之后指针还留着,指向已释放的内存。再访问它是未定义行为——可能读到垃圾,也可能"看起来正常"从而埋下更深的隐患。
  3. 双重释放(double free):同一块内存 delete 两次,堆管理器直接崩溃。

Java/Python/JS 程序员很少遇到这些,因为 GC 保证"只要还被引用就不会回收"。但 GC 也有代价:不可预测的停顿(STW)、更高的内存占用、无法精确控制释放时机(文件句柄、锁这类资源不能等 GC)。C++ 的答案是:不引入 GC,而是用智能指针把 delete 自动化。

C++
#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()) 这种参数求值顺序导致的泄漏),且代码更短。

C++
#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 或栈对象就别用。

C++
#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;
}

#智能指针选型速查

三种智能指针:所有权语义对比定义在 <memory> 中,均基于 RAII 自动释放资源unique_ptr 独占所有权std::unique_ptr<T> upT 对象(堆上)拷贝构造 / 赋值被 = delete 禁用转移只能用 up2 = std::move(up1)禁止拷贝 copy = deleteshared_ptr 共享所有权shared_ptrshared_ptrT 对象 + 控制块引用计数 = 2计数归零时自动 delete 对象注意避免循环引用导致泄漏weak_ptr 弱引用(观察者)std::weak_ptr<T> wpT 对象(由 shared_ptr 持有)不增加引用计数使用前需 wp.lock() 提升为 shared_ptr用于打破循环引用 / 缓存观察者
unique_ptr / shared_ptr / weak_ptr 的所有权模型
场景选择说明
默认情况栈对象最快、最安全,无需指针
需要动态分配、独占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。

C++
#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;
}

#小结

  1. 栈对象由编译器管理、生命周期确定、速度最快;堆对象需手动管理但可跨作用域。默认用栈,需要多态或大对象时才用堆。
  2. 裸 new/delete 的三大灾难是内存泄漏、悬垂指针、双重释放;delete 后应立即把指针置空。
  3. std::unique_ptr 表达独占所有权,零开销(大小等于裸指针),不可拷贝只能移动,是动态分配的默认选择;始终用 make_unique 创建。
  4. std::shared_ptr 用引用计数实现共享所有权,思路与 Python 的引用计数类似,但没有循环垃圾回收器兜底,互相持有会导致泄漏。
  5. std::weak_ptr 不增加引用计数,用于打破循环引用和观察可能已销毁的对象;使用前必须 lock() 升级。
  6. 智能指针能管的不止内存:配合自定义删除器可以管理文件句柄、socket、锁等任何成对资源。

#练习

  1. 写一个函数,用 new 分配一个 1000 元素的 int 数组,在中间 return 前故意不 delete,用循环调用 10000 次并观察内存占用(macOS 用活动监视器,Linux 用 top)。然后用 std::unique_ptr<int[]> 重写,对比结果。
  2. 实现 struct TreeNode { std::string name; std::vector<std::unique_ptr<TreeNode>> children; TreeNode* parent; },写一个 add_child 函数和一个 print 递归打印函数。思考为什么子节点用 unique_ptr、父节点用裸指针。
  3. 构造一个循环引用:两个 struct 互相持有 shared_ptr,运行后观察析构函数是否被调用。然后把其中一个改成 weak_ptr,验证泄漏消失。
  4. 用 unique_ptr + 自定义删除器包装 std::FILE*(参考最后一节),再包装一个 int* 数组删除器 [](int* p){ delete[] p; },体会删除器的通用性。最后把练习 2 的树改成 shared_ptr 版本,讨论什么业务场景下共享所有权才是合理的。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。