第6章内存管理

课程目录第6章内存管理

第六章内存管理：堆与栈的博弈

内存管理这个话题，说实话，是C/C++程序员从入门到进阶的一道分水岭。我见过太多人写了几年代码，还在被段错误和内存泄漏追着跑。今天咱们就把这块硬骨头啃下来。

6.1 堆与栈：两个世界

栈和堆，名字听着像两兄弟，实际上性格完全不同。栈是系统自动管理的，堆得咱们自己操心。你想想看，栈上分配一个int，就是一条指令的事；堆上new一个对象，背后可能跑了一大堆逻辑。

核心区别速览：

栈：自动分配、自动释放，速度快，容量小（通常几MB）
堆：手动分配、手动释放，速度慢，容量大（取决于系统内存）

我在项目中遇到过一个问题：一个同事在栈上声明了一个1MB的局部数组，程序一跑就崩。为什么？栈空间不够啊！Windows默认栈大小也就1MB左右，Linux是8MB。你想想看，一个数组就占满了，函数调用还得压栈呢。

// 栈上分配 - 危险操作
void dangerous() {
    char buffer[1024 * 1024];  // 1MB，很可能栈溢出！
    // ...
}

// 堆上分配 - 安全操作
void safe() {
    char* buffer = new char[1024 * 1024];  // 堆上分配，没问题
    // ...
    delete[] buffer;  // 别忘了释放
}

注意：栈上分配的对象，生命周期由作用域决定。出了花括号，自动析构。堆上分配的对象，你得亲手delete，否则就泄漏了。我曾经在一个服务端项目里，因为忘记delete一个临时对象，内存以每小时200MB的速度增长，跑了三天才被发现。

6.2 new/delete 与 malloc/free：不只是语法糖

很多初学者觉得new/delete和malloc/free就是一回事。其实不然。malloc/free是C标准库的函数，new/delete是C++的运算符。区别在哪？new除了分配内存，还会调用构造函数；delete会调用析构函数再释放内存。

// malloc/free - 只分配内存，不构造对象
int* p = (int*)malloc(sizeof(int));
*p = 42;  // 手动初始化
free(p);

// new/delete - 分配内存 + 构造对象
int* q = new int(42);  // 自动初始化
delete q;  // 析构 + 释放

说白了，对于内置类型，两者差别不大。但对于类对象，差别就大了。new会调用构造函数，malloc不会。我见过有人用malloc分配了一个std::string对象，然后直接赋值——结果程序崩溃得一塌糊涂。为什么？string的构造函数没跑，内部指针是野的。

我的建议：C++代码里统一用new/delete，别混用。混用malloc和delete，或者new和free，属于未定义行为，编译器不会报错，但运行时可能随时爆炸。

6.3 内存池设计：自己管内存

频繁的new/delete会导致什么问题？内存碎片！你想想看，分配、释放、再分配、再释放，堆上的空闲块变得七零八落。系统找一块连续的大内存越来越费劲。这时候，内存池就派上用场了。

内存池的核心思想很简单：一次性从系统申请一大块内存，然后自己管理这块内存的分配和回收。说白了，就是当个二房东。

// 一个简单的固定大小内存池
class FixedAllocator {
    struct Block {
        Block* next;
    };
    Block* freeList;
    static const size_t BLOCK_SIZE = 64;
    static const size_t POOL_SIZE = 1024;
    char pool[POOL_SIZE * BLOCK_SIZE];
    
public:
    FixedAllocator() {
        // 初始化空闲链表
        freeList = reinterpret_cast<Block*>(pool);
        Block* current = freeList;
        for (size_t i = 1; i < POOL_SIZE; ++i) {
            current->next = reinterpret_cast<Block*>(pool + i * BLOCK_SIZE);
            current = current->next;
        }
        current->next = nullptr;
    }
    
    void* allocate() {
        if (!freeList) return nullptr;  // 内存耗尽
        Block* block = freeList;
        freeList = freeList->next;
        return block;
    }
    
    void deallocate(void* ptr) {
        Block* block = static_cast<Block*>(ptr);
        block->next = freeList;
        freeList = block;
    }
};

这个例子展示的是固定大小内存池。实际项目中，我更喜欢用变长内存池，或者用现成的库比如jemalloc、tcmalloc。嗯，这里要注意：内存池不是万能的。如果你的对象大小差异很大，固定大小池子会浪费空间。变长池子管理起来又复杂。

什么时候该用内存池？

频繁分配/释放大量小对象（比如网络连接、游戏中的子弹）
对实时性要求高，不能忍受malloc的不可预测延迟
需要避免内存碎片

6.4 内存对齐与缓存行：性能的隐形杀手

内存对齐，说白了就是数据在内存里的摆放规则。CPU读取内存不是按字节读的，而是按块读的。这个块的大小，通常是4字节、8字节或者16字节。如果你的数据跨了块边界，CPU就得读两次，性能就下来了。

// 不对齐的结构体
struct Bad {
    char a;    // 1字节
    int b;     // 4字节，从偏移1开始，不对齐！
    short c;   // 2字节
};
// sizeof(Bad) = 12，实际只用了7字节，浪费5字节

// 对齐的结构体
struct Good {
    int b;     // 4字节，从偏移0开始
    short c;   // 2字节，从偏移4开始
    char a;    // 1字节，从偏移6开始
};
// sizeof(Good) = 8，只浪费1字节

为什么会这样？因为编译器会在成员之间插入填充字节，保证每个成员都对齐到它的自然边界。你想想看，int是4字节，它的地址必须是4的倍数。char是1字节，随便放哪都行。

缓存行就更微妙了。现代CPU的缓存是以缓存行（通常64字节）为单位加载的。如果两个线程频繁访问的数据恰好在同一个缓存行里，就会发生伪共享——明明操作的是不同变量，却互相拖慢速度。

我曾经踩过的坑：一个多线程日志系统，每个线程有自己的日志缓冲区。缓冲区在内存里是连续分配的，结果两个线程的缓冲区恰好落在同一个缓存行里。一个线程写日志，另一个线程的缓冲区就被迫刷新缓存。性能直接腰斩。解决方案？在每个缓冲区后面填充64字节，保证它们不在同一个缓存行里。

// 避免伪共享 - 缓存行对齐
struct alignas(64) ThreadLocalBuffer {
    char data[1024];
    size_t length;
    // 填充到64字节对齐
    char padding[64 - sizeof(size_t) % 64];
};

小技巧：C++11开始可以用alignas关键字指定对齐方式。C11有_Alignas。如果你还在用老标准，可以用编译器属性：__attribute__((aligned(64))) 或者 __declspec(align(64))。

知识体系总览

下面这张图把本章的核心逻辑串起来了。从栈和堆的底层差异，到new/delete与malloc/free的选择，再到内存池和缓存行优化——每一步都是性能的关键节点。

内存管理这块，说白了就是平衡的艺术。栈快但小，堆大但慢。new/delete方便但有开销，内存池高效但复杂。缓存行对齐能提速，但过度对齐会浪费空间。没有银弹，只有根据场景做取舍。

我个人习惯是：能用栈绝不用堆，能用值类型绝不用指针。实在要用堆，优先考虑智能指针。如果性能敏感，再上内存池。至于缓存行对齐，那是多线程编程的必修课，逃不掉的。

公众号:蓝海资料掘金营，微信deep3321

📚 课程目录

第六章 内存管理：堆与栈的博弈

6.1 堆与栈：两个世界

6.2 new/delete 与 malloc/free：不只是语法糖

6.3 内存池设计：自己管内存

6.4 内存对齐与缓存行：性能的隐形杀手

知识体系总览

第六章内存管理：堆与栈的博弈