第9章内存分配与释放

课程目录第9章内存分配与释放

内存分配与释放：从底层到工程实践

内存管理这个话题，说实话，是C++性能优化的核心战场之一。我见过太多项目，明明算法写得不错，却被内存分配拖垮了性能。今天我们就来聊聊new/delete、malloc/free、内存池、对象池，以及栈分配与堆分配这些话题。

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

很多人觉得new/delete就是malloc/free的C++版本，其实没那么简单。我刚开始做C++时也这么想，直到有一次排查内存泄漏，才发现问题出在构造函数没被调用。

核心区别：

malloc/free只分配和释放内存，不调用构造函数/析构函数
new/delete会调用构造函数/析构函数，这是C++对象模型的基础

// 看看区别
// malloc方式
MyClass* p = (MyClass*)malloc(sizeof(MyClass));
// p指向的内存是原始字节，MyClass的构造函数没有被调用
// 直接使用p->method()会导致未定义行为

// new方式
MyClass* p = new MyClass();
// 分配内存 + 调用构造函数，一步到位

我曾经踩过的坑：在嵌入式项目中，有人用malloc分配了一个包含std::string成员的结构体，然后直接赋值。结果string的内部指针指向了未初始化的内存，程序崩溃得莫名其妙。记住：C++对象一定要用new。

性能方面，new比malloc多了一个构造函数调用开销。但说实话，这个开销通常不是瓶颈。真正的性能杀手是频繁的堆分配本身。

内存池设计：解决频繁分配的核心武器

为什么需要内存池？你想想看，每次调用malloc/new，操作系统都要在堆上找一块合适大小的空闲内存。这个过程涉及系统调用、锁竞争、内存碎片整理……开销不小。

我个人习惯在以下场景使用内存池：

需要频繁创建和销毁大量小对象（比如网络连接、游戏中的子弹）
对象大小固定或变化范围很小
对延迟敏感，不能容忍堆分配的不确定性

一个简单的内存池实现思路：

template<typename T, size_t BlockSize = 1024>
class MemoryPool {
private:
    struct Block {
        char data[sizeof(T)];
        Block* next;
    };
    
    Block* freeList = nullptr;
    
public:
    T* allocate() {
        if (!freeList) {
            // 分配一大块内存
            freeList = static_cast<Block*>(::operator new(BlockSize * sizeof(Block)));
            // 构建空闲链表
            for (size_t i = 0; i < BlockSize - 1; ++i) {
                freeList[i].next = &freeList[i + 1];
            }
            freeList[BlockSize - 1].next = nullptr;
        }
        
        Block* p = freeList;
        freeList = freeList->next;
        return reinterpret_cast<T*>(p);
    }
    
    void deallocate(T* p) {
        Block* block = reinterpret_cast<Block*>(p);
        block->next = freeList;
        freeList = block;
    }
};

关键点：内存池的核心思想是「一次大分配，多次小复用」。把系统调用的次数从O(N)降到O(1)，性能提升非常明显。我在游戏服务器项目中用过这个模式，对象创建速度提升了5倍以上。

对象池：比内存池更进一步

对象池和内存池的区别在哪里？说白了，对象池不仅管理内存，还管理对象的生命周期。它预先创建好一批对象，用的时候直接拿，用完放回去，省去了构造和析构的开销。

我建议在以下情况使用对象池：

对象构造/析构开销大（比如数据库连接、线程）
对象数量有上限，且可以复用
需要控制资源总量，防止系统过载

class ConnectionPool {
private:
    std::vector<Connection*> available;
    std::mutex mtx;
    
public:
    Connection* acquire() {
        std::lock_guard<std::mutex> lock(mtx);
        if (available.empty()) {
            return new Connection(); // 池为空时才创建新对象
        }
        Connection* conn = available.back();
        available.pop_back();
        conn->reset(); // 重置状态，而不是重新构造
        return conn;
    }
    
    void release(Connection* conn) {
        std::lock_guard<std::mutex> lock(mtx);
        available.push_back(conn);
    }
};

避坑指南：对象池里的对象一定要有「重置」方法。我曾经见过一个项目，从对象池拿出来的连接还带着上次请求的数据，导致数据错乱。记住：复用不等于不清理。

栈分配 vs 堆分配：性能差距有多大？

这个问题其实很简单：栈分配就是「弹一下栈指针」，堆分配要「找空闲块、更新链表、可能触发系统调用」。性能差距通常在10-100倍之间。

为什么会这样？因为栈是连续的，分配和释放都是O(1)操作。堆则要处理碎片、锁竞争等问题。

我的建议：

能用栈就别用堆：小对象、生命周期明确的对象，直接定义在栈上
大对象（>1MB）必须用堆：栈空间有限，通常只有几MB
动态大小用堆：比如std::vector内部就是堆分配
跨函数传递用堆：栈对象在函数返回后就被销毁了

// 栈分配（推荐）
void process() {
    int buffer[1024]; // 8KB，在栈上
    // 直接使用，无需释放
}

// 堆分配（必要时才用）
void process() {
    int* buffer = new int[1024 * 1024]; // 8MB，必须用堆
    // 使用完后必须delete[]
    delete[] buffer;
}

注意：栈溢出是个很隐蔽的问题。我记得有一次调试一个递归算法，递归深度稍微大了点，程序就莫名其妙崩溃。查了半天才发现是栈空间不够了。Windows默认栈大小是1MB，Linux是8MB，心里要有数。

知识体系总览

下面这张图总结了本章的核心内容，帮你理清思路：

总结一下

内存管理没有银弹。栈分配最快但限制多，堆分配灵活但开销大，内存池和对象池是中间方案。我个人习惯是：默认用栈，必要时用池，万不得已才直接new。

你在实际项目中遇到内存相关的性能问题了吗？不妨从分配频率和对象大小入手分析，往往能找到优化空间。

📚 课程目录

内存分配与释放：从底层到工程实践

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

内存池设计：解决频繁分配的核心武器

对象池：比内存池更进一步

栈分配 vs 堆分配：性能差距有多大？

知识体系总览

总结一下