第36章内存管理深入

课程目录第36章内存管理深入

第36章：内存管理深入：栈与堆的区别、内存池设计、对象池、placement new、对齐

内存管理，说白了就是C++程序员和操作系统之间的「地盘争夺战」。你申请，它分配；你用完了，得还回去。但怎么申请、从哪申请、申请完怎么用——这里头的门道，我踩过的坑可不少。

今天咱们就把栈、堆、内存池、对象池、placement new和对齐这几个硬骨头，一块啃干净。

36.1 栈与堆：两个世界，两种活法

先问个问题：你写的局部变量存在哪？用new出来的对象又存在哪？

答案是：局部变量在栈上，new出来的在堆上。但区别远不止「位置」这么简单。

对比维度	栈（Stack）	堆（Heap）
分配方式	编译器自动分配、释放	程序员手动申请、释放
速度	极快（仅移动栈指针）	较慢（需要查找空闲块）
大小限制	通常几MB（可调但有限）	受虚拟内存限制（GB级别）
生命周期	函数结束即销毁	直到手动delete或程序结束
碎片问题	无碎片（严格LIFO）	容易产生外部碎片

我个人习惯：能用栈绝不用堆。栈分配就是一条指令的事，堆分配背后可能触发系统调用、锁竞争、内存碎片整理——慢得你心疼。

核心原则：栈是性能利器，堆是灵活之源。小对象、短生命周期用栈；大对象、动态生命周期用堆。

36.2 内存池设计：自己管自己，快就一个字

堆分配慢在哪？每次malloc都要去查空闲链表，多线程下还要加锁。如果你频繁申请释放固定大小的对象，为什么不自己搞个「预分配仓库」？

这就是内存池的核心思想：一次性从系统申请一大块内存，然后自己切成小块，按需分配。没有系统调用，没有锁竞争（如果设计得当）。

// 一个极简的固定大小内存池
class FixedMemoryPool {
    struct Block {
        Block* next;
    };
    Block* freeList;
    char* pool;
    size_t blockSize;
    size_t poolSize;
public:
    FixedMemoryPool(size_t bSize, size_t count)
        : blockSize(bSize), poolSize(bSize * count) {
        pool = new char[poolSize];
        freeList = reinterpret_cast<Block*>(pool);
        Block* current = freeList;
        for (size_t i = 1; i < count; ++i) {
            current->next = reinterpret_cast<Block*>(pool + i * blockSize);
            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;
    }
    ~FixedMemoryPool() { delete[] pool; }
};

你看，分配就是取链表头，释放就是插回链表头——O(1)操作。我在项目中用这个模式处理网络连接对象，吞吐量直接翻倍。

我的经验：内存池最适合「固定大小、频繁分配释放」的场景。比如游戏引擎中的粒子、网络库中的连接对象。如果对象大小不一，那就得考虑更复杂的伙伴系统或slab分配器了。

36.3 对象池：不止是内存，还有构造与析构

内存池只管「内存块」，对象池管的是「对象」。区别在哪？对象池会帮你调用构造函数和析构函数。

说白了，对象池 = 内存池 + 构造/析构管理。它特别适合那些「创建销毁代价高」的对象，比如数据库连接、线程池中的任务。

template<typename T>
class ObjectPool {
    FixedMemoryPool pool;
    std::vector<T*> activeObjects;
public:
    ObjectPool(size_t count) : pool(sizeof(T), count) {}
    
    template<typename... Args>
    T* acquire(Args&&... args) {
        void* mem = pool.allocate();
        if (!mem) return nullptr;
        T* obj = new (mem) T(std::forward<Args>(args)...);
        activeObjects.push_back(obj);
        return obj;
    }
    
    void release(T* obj) {
        obj->~T();  // 显式调用析构
        pool.deallocate(obj);
        // 从activeObjects中移除...
    }
};

注意那个new (mem) T(...)——这就是我们马上要讲的placement new。它只构造，不分配内存。

我曾经踩过的坑：对象池中的对象析构后，内存块回到池中，但如果你忘记调用析构函数，资源泄漏就来了。比如对象内部持有文件句柄或互斥锁，不析构就永远不释放。所以对象池的release一定要显式调用析构。

36.4 Placement New：在指定内存上构造对象

常规的new干两件事：分配内存 + 调用构造函数。Placement new只干第二件。

语法很简单：new (address) Type(args)。地址你得自己提供——可以是栈上的、内存池里的、甚至mmap映射的共享内存。

#include <new>  // 必须包含

// 在栈上构造
alignas(alignof(std::string)) char buffer[sizeof(std::string)];
std::string* str = new (buffer) std::string("Hello, placement new!");

// 用完手动析构
str->~std::string();

为什么要用它？场景很明确：

内存池/对象池：内存已经预分配，只需构造
共享内存：两个进程共享一块内存，各自在上面构造对象
避免默认构造：某些场景下你不想先构造再赋值，想直接构造在目标位置

注意：用placement new构造的对象，必须手动调用析构函数。不要用delete——它会尝试释放内存，而这块内存不是你用new分配的。后果嘛……未定义行为，程序可能直接崩。

36.5 对齐（alignas / alignof）：CPU喜欢整齐的数据

CPU读取内存不是按字节来的，而是按「字」——4字节、8字节、16字节。如果数据没对齐，CPU得读两次再拼起来，性能直接腰斩。

对齐说白了就是：变量的地址必须是其大小的整数倍。比如int是4字节，地址必须是4的倍数；double是8字节，地址必须是8的倍数。

#include <iostream>
#include <cstddef>

struct alignas(16) AlignedStruct {
    float x, y, z, w;  // 16字节对齐，适合SIMD
};

int main() {
    std::cout << "默认对齐: " << alignof(AlignedStruct) << "\n";
    // 输出: 16
    
    AlignedStruct a;
    std::cout << "地址偏移: " << (reinterpret_cast<uintptr_t>(&a) & 0xF) << "\n";
    // 输出: 0（16字节对齐）
    
    return 0;
}

alignas用来指定对齐方式，alignof用来查询对齐要求。C++11开始支持，之前只能用编译器扩展。

我的建议：如果你用SIMD指令（SSE/AVX），数据对齐是刚需。不对齐的SIMD加载指令在某些平台上会直接崩溃。我当年写图像处理库时，就因为一个结构体没对齐，在ARM上跑得好好的，x86上随机崩溃——查了两天才发现是__m128i没对齐。

36.6 知识体系总览

下面这张图把本章的核心脉络串起来了：

36.7 总结与避坑

好，咱们把今天的内容串起来捋一遍：

栈 vs 堆：栈快但小，堆大但慢。选哪个看场景。
内存池：预分配一大块，自己切小块。适合固定大小、高频分配的场景。
对象池：内存池 + 构造/析构管理。适合创建销毁代价高的对象。
Placement new：在已有内存上构造对象。配合内存池/对象池使用，威力巨大。
对齐：CPU喜欢整齐的数据。用alignas指定，用alignof查询。SIMD场景下是刚需。

我曾经踩过的坑（再补一个）：有一次我写一个高性能日志库，用了内存池来管理日志条目。一切看起来完美，直到压力测试时发现内存池里的对象析构函数没被调用——日志条目里有个std::string，不析构就永远不释放内存。结果内存池本身没泄漏，但池里每个对象内部的内存全泄漏了。从那以后，我每次设计对象池都会在release里显式调用析构，绝不偷懒。

内存管理是C++程序员的必修课。你想想看，一个程序跑得再快，如果内存管理一塌糊涂，迟早要出问题。把这些基础打牢，后面写高性能组件时才能游刃有余。

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

📚 课程目录