重载 new[] 和 delete[] 运算符：管理动态数组的内存分配与释放

动态数组的内存管理，说白了就是让 C++ 知道「你要怎么分配和释放一堆连续的对象」。默认的 new[] 和 delete[] 已经够用了，但当你需要自定义内存池、统计分配次数、或者对齐特殊硬件时，就得自己动手重载它们。

我个人习惯把这两个运算符看作一对「搭档」——你重载了 new[]，就一定要重载 delete[]，否则程序跑起来会出大问题。嗯，这里要注意：它们和 new/delete 是两套独立的运算符，别搞混了。

为什么需要重载 new[] 和 delete[]？

默认的 new[] 会从堆上分配连续内存，然后对每个元素调用构造函数。但有些场景下默认行为不够用：

• 内存池优化：频繁分配小数组时，系统开销很大。自己管理一块预分配的内存能提升性能。
• 统计与调试：我想知道程序里到底分配了多少数组、每个数组多大。重载后可以埋点计数。
• 对齐要求：某些硬件（比如 SIMD 指令集）要求数据按 16 字节或 32 字节对齐。默认分配器不保证这个。
• 特殊内存区域：比如分配在共享内存、GPU 显存或非易失性内存上。

我在项目中遇到过这样一个坑：一个实时音频处理模块，频繁创建和销毁小数组，导致堆碎片化严重，最终程序跑了几小时就崩了。后来重载了 new[] 和 delete[]，用固定大小的内存池解决。你想想看，如果当时没这招，项目可能就黄了。

重载的基本语法

重载 new[] 和 delete[] 有两种方式：作为类的静态成员函数，或者作为全局函数。我建议优先用成员函数形式，这样只影响特定类，不会污染全局。

class MyClass {
public:
    // 重载 new[]
    void* operator new[](size_t size) {
        std::cout << "分配数组，大小: " << size << " 字节\n";
        void* ptr = std::malloc(size);
        if (!ptr) throw std::bad_alloc();
        return ptr;
    }

    // 重载 delete[]
    void operator delete[](void* ptr) {
        std::cout << "释放数组内存\n";
        std::free(ptr);
    }
};

注意 size_t size 参数——它表示要分配的字节总数，不是元素个数。编译器会自动计算：sizeof(MyClass) * 元素个数 + 可能的额外开销。这个额外开销是啥？后面会讲。

数组分配中的隐藏开销

你可能会问：为什么 new[] 分配的大小比 sizeof(T) * n 多出几个字节？

这是因为编译器需要在内存块头部存储数组的元素个数。当调用 delete[] 时，它才知道要调用多少次析构函数。这个隐藏的「计数头」通常占 4 或 8 字节，具体看平台。

我曾经调试过一个诡异的内存泄漏：重载了 new[] 但没考虑这个头部开销，导致 delete[] 读取了错误的值，析构函数少调用了好几次。嗯，从那以后我每次重载都会在代码里加注释提醒自己。

带对齐要求的重载

C++17 引入了 std::align_val_t 参数，用于指定对齐方式。如果你的类需要特殊对齐，可以这样重载：

class AlignedClass {
public:
    static constexpr std::size_t alignment = 64; // 64 字节对齐

    void* operator new[](std::size_t size, std::align_val_t al) {
        std::cout << "对齐分配，大小: " << size << "，对齐: "
                  << static_cast<std::size_t>(al) << "\n";
        void* ptr = std::aligned_alloc(static_cast<std::size_t>(al), size);
        if (!ptr) throw std::bad_alloc();
        return ptr;
    }

    void operator delete[](void* ptr, std::align_val_t) {
        std::free(ptr); // aligned_alloc 分配的内存可以用 free 释放
    }
};

这里要注意：std::aligned_alloc 要求 size 必须是对齐值的整数倍，否则行为未定义。我在写 SIMD 向量类时踩过这个坑——分配了 65 字节给 64 字节对齐的数组，结果 aligned_alloc 返回了空指针。

placement new[] 和对应的 delete[]

有时候你不想分配内存，只想在已有内存上构造数组。这时候用 placement new[]。但要注意，placement delete[] 不会释放内存，它只调用析构函数。

void* buffer = std::malloc(sizeof(MyClass) * 10);
MyClass* arr = new (buffer) MyClass[10]; // placement new[]

// 使用数组...

// 手动调用析构函数，然后释放内存
for (int i = 0; i < 10; ++i) {
    arr[i].~MyClass();
}
std::free(buffer);

我个人不太推荐频繁使用 placement new[]，因为手动管理生命周期容易出错。除非你写内存池或嵌入式代码，否则尽量用标准容器。

避坑指南：重载时的常见错误

我见过不少同事在重载 new[] 和 delete[] 时翻车，这里列几个典型：

• 忘记匹配：重载了 new[] 但没重载 delete[]，或者参数不匹配。编译器不会报错，但运行时会调用默认版本，导致内存管理混乱。
• 忽略异常安全：如果构造函数抛出异常，编译器会自动调用对应的 delete[] 释放已分配的内存。但如果你重载了 new[] 且分配了额外资源，要确保异常时能正确回滚。
• 误用 delete 代替 delete[]：这个经典错误在重载场景下更隐蔽——如果你用 delete 释放 new[] 分配的内存，可能只调用一次析构函数，而且计数头没被正确解析。
• 全局重载的副作用：全局重载 new[] 会影响所有类的数组分配，包括标准库内部。除非你清楚后果，否则别轻易碰全局版本。

知识体系结构图

下面这张图梳理了 new[] 和 delete[] 重载的核心脉络，从为什么需要到怎么实现，再到常见陷阱：

一个完整的示例

最后，给你看一个我实际用过的内存池版本。它预分配一大块内存，然后按需分配小数组，避免频繁调用系统 malloc：

class MemoryPool {
    static constexpr size_t POOL_SIZE = 1024 * 1024; // 1MB
    char pool[POOL_SIZE];
    size_t offset = 0;

public:
    void* allocate(size_t size) {
        if (offset + size > POOL_SIZE) {
            throw std::bad_alloc();
        }
        void* ptr = pool + offset;
        offset += size;
        return ptr;
    }

    void deallocate(void*) {
        // 简单实现：不真正释放，重置整个池
        // 实际项目中可以用更复杂的策略
    }
};

class PoolUser {
    static MemoryPool& getPool() {
        static MemoryPool pool;
        return pool;
    }

public:
    void* operator new[](size_t size) {
        return getPool().allocate(size);
    }

    void operator delete[](void* ptr) {
        getPool().deallocate(ptr);
    }
};

这个例子简化了很多细节，但核心思路就是：重载 new[] 和 delete[] 让你能完全控制数组内存的分配与释放。你想想看，如果每个小数组都走系统堆，性能损失有多大？

好了，关于 new[] 和 delete[] 的重载就聊到这儿。记住：成对重载、考虑计数头、注意异常安全——这三点做到，基本不会出大问题。

---