【C++特殊工具与技术】优化内存分配(三)：operator new函数和opertor delete函数

byte轻骑兵

发布于 2026-01-21 18:42:33

1240

内存管理是 C++ 的核心能力之一，而operator new和operator delete作为内存分配的底层接口，是理解 C++ 对象生命周期的关键。

一、基础概念：`operator new`与`operator delete`的本质

在 C++ 中，new和delete有两层含义：

表达式：如int* p = new int(10);，负责内存分配 + 对象构造（或delete p;负责对象析构 + 内存释放）。
操作符函数：即operator new和operator delete，是new/delete表达式调用的底层内存分配 / 释放函数。

核心关系：new表达式的执行流程是：

调用operator new分配原始内存；
调用对象的构造函数（若为类类型）；反之，delete表达式的流程是：
调用对象的析构函数（若为类类型）；
调用operator delete释放内存。

1.1 标准库提供的`operator new`接口

C++ 标准库定义了多组operator new和operator delete的重载形式，覆盖不同场景的内存分配需求。以下是最核心的 4 种形式（以 64 位系统为例）：

①普通内存分配（抛出异常）

// 分配size字节的原始内存，失败时抛出std::bad_alloc异常
void* operator new(std::size_t size);
void* operator new[](std::size_t size); // 数组版本

②不抛出异常的分配（nothrow 版本）

// 分配失败时返回nullptr，不抛出异常
void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;

③定位分配（placement new）

// 在已分配的内存地址ptr处构造对象（不分配内存）
void* operator new(std::size_t, void* ptr) noexcept;
void* operator new[](std::size_t, void* ptr) noexcept;

1.2 标准库`operator delete`的接口

operator delete的职责是释放operator new分配的内存，其接口与operator new一一对应：

// 普通释放（与普通operator new配对）
void operator delete(void* ptr) noexcept;
void operator delete[](void* ptr) noexcept;

// 与nothrow版本配对的释放函数
void operator delete(void* ptr, const std::nothrow_t&) noexcept;
void operator delete[](void* ptr, const std::nothrow_t&) noexcept;

// 与对齐分配配对的释放函数（C++17）
void operator delete(void* ptr, std::align_val_t align) noexcept;
void operator delete[](void* ptr, std::align_val_t align) noexcept;

1.3 关键特性总结

特性	说明
全局默认实现	标准库提供的operator new底层调用malloc，operator delete调用free
异常行为	普通版本分配失败抛std::bad_alloc，nothrow 版本返回nullptr
内存对齐	普通版本保证至少alignof(std::max_align_t)（通常为 16 字节）的对齐
数组与标量差异	operator new[]和operator delete[]用于数组，实现上可能多分配额外空间存储数组大小

二、`new`表达式与`operator new`的调用链解析

要理解operator new的作用，必须明确new表达式的完整执行流程。以类对象为例：

class MyClass { 
public: 
    MyClass(int x) : val(x) {} 
private: 
    int val; 
};

MyClass* obj = new MyClass(10); // new表达式

2.1 `new`表达式的底层步骤

调用operator new：分配足够大的内存（大小为sizeof(MyClass)）。
调用构造函数：在分配的内存地址上调用MyClass::MyClass(int)。
返回对象指针：若构造成功，返回指向对象的指针；若构造或分配失败，释放已分配的内存并抛出异常。

2.2 示例：观察`new`表达式的调用过程

通过重载全局operator new并添加日志，可以验证上述流程：

#include <iostream>
#include <new>
#include <cstdlib>

// 重载全局operator new（普通版本）
void* operator new(std::size_t size) {
    std::cout << "全局operator new被调用，分配大小：" << size << "字节" << std::endl;
    void* ptr = std::malloc(size); // 调用malloc分配内存
    if (!ptr) throw std::bad_alloc{};
    return ptr;
}

// 重载全局operator delete（普通版本）
void operator delete(void* ptr) noexcept {
    std::cout << "全局operator delete被调用" << std::endl;
    std::free(ptr); // 调用free释放内存
}

class MyClass {
public:
    MyClass(int x) : val(x) { std::cout << "MyClass构造函数被调用" << std::endl; }
    ~MyClass() { std::cout << "MyClass析构函数被调用" << std::endl; }
private:
    int val;
};

int main() {
    MyClass* obj = new MyClass(10); // new表达式
    delete obj;                     // delete表达式
    return 0;
}

输出结果：

new表达式先调用operator new分配内存，再调用构造函数；
delete表达式先调用析构函数，再调用operator delete释放内存；
分配的内存大小等于对象类型的大小（sizeof(MyClass)=4，因int val占 4 字节）。

三、自定义`operator new`与`operator delete`

标准库的operator new基于malloc实现，虽然通用但可能在特定场景下效率不足（如高频小对象分配导致内存碎片）。通过自定义operator new，可以实现内存池、对齐优化、性能监控等高级功能。

3.1 自定义的动机与场景

场景	自定义方案
减少内存碎片	实现小对象内存池（如每 8 字节为一个块，预分配连续内存）
提升分配速度	绕过malloc的全局锁，使用线程本地内存池
内存对齐优化	为特定类型（如图像数据、SIMD 指令数据）提供更高对齐的内存
内存泄漏检测	在分配时记录内存地址，释放时检查是否重复释放
调试与监控	统计各类型的内存使用量，定位内存分配热点

3.2 类特定的`operator new`重载

最常见的自定义方式是为某个类单独重载operator new和operator delete，使该类的所有对象分配都使用自定义逻辑。

示例：为类实现内存池

以下代码为SmallObject类实现一个简单的内存池，用于管理高频分配的小对象（假设对象大小≤64 字节）：

#include <iostream>
#include <vector>
#include <cstddef>
#include <cstdlib>

class SmallObject {
public:
    static void* operator new(std::size_t size);
    static void operator delete(void* ptr, std::size_t size);

    // 测试用构造函数
    SmallObject(int x) : value(x) {}
    int value;
};

// 内存池实现（简化版）
class MemoryPool {
private:
    static constexpr std::size_t BLOCK_SIZE = 4096;    // 每个内存块大小（4KB）
    static constexpr std::size_t OBJECT_SIZE = 64;     // 最大小对象大小
    std::vector<char*> blocks;                         // 已分配的内存块
    char* currentBlock = nullptr;                      // 当前块指针
    char* currentPos = nullptr;                        // 当前分配位置

public:
    MemoryPool() { allocateNewBlock(); }

    void* allocate(std::size_t size) {
        if (size > OBJECT_SIZE) {
            return std::malloc(size); // 大对象直接调用malloc
        }
        if (currentPos + size > currentBlock + BLOCK_SIZE) {
            allocateNewBlock(); // 当前块不足，分配新块
        }
        void* ptr = currentPos;
        currentPos += size;
        return ptr;
    }

    void deallocate(void* ptr, std::size_t size) {
        if (size > OBJECT_SIZE) {
            std::free(ptr); // 大对象直接调用free
            return;
        }
        // 简单内存池不回收单个对象，实际可扩展为空闲链表
    }

private:
    void allocateNewBlock() {
        currentBlock = static_cast<char*>(std::malloc(BLOCK_SIZE));
        if (!currentBlock) throw std::bad_alloc{};
        blocks.push_back(currentBlock);
        currentPos = currentBlock;
        std::cout << "分配新内存块，地址：" << static_cast<void*>(currentBlock) << std::endl;
    }
};

// 静态内存池实例
static MemoryPool smallObjectPool;

// 类特定的operator new
void* SmallObject::operator new(std::size_t size) {
    return smallObjectPool.allocate(size);
}

// 类特定的operator delete
void SmallObject::operator delete(void* ptr, std::size_t size) {
    smallObjectPool.deallocate(ptr, size);
}

int main() {
    // 测试小对象分配
    SmallObject* obj1 = new SmallObject(10);
    SmallObject* obj2 = new SmallObject(20);
    std::cout << "obj1地址：" << obj1 << std::endl;
    std::cout << "obj2地址：" << obj2 << std::endl;

    delete obj1;
    delete obj2;

    return 0;
}

输出结果：

注意：两个对象地址连续，间隔4字节（int大小）

内存池预分配 4KB 的内存块，小对象分配时直接从块中划分，避免频繁调用malloc；
operator new和operator delete通过静态MemoryPool实例管理内存；
实际生产环境中，内存池需要实现空闲链表（free list）来回收释放的内存，避免内存浪费。

3.3 全局`operator new`的重载

全局重载会影响所有未显式定义类特定operator new的类型，需谨慎使用。常见场景是实现全局内存监控或调试工具。

示例：全局内存分配监控

通过全局重载operator new和operator delete，记录每次分配的内存大小和地址，用于检测内存泄漏：

#include <iostream>
#include <new>
#include <unordered_map>
#include <mutex>

// 全局内存分配统计
static std::unordered_map<void*, std::size_t> allocatedMemory;
static std::mutex mtx;

// 重载全局operator new（普通版本）
void* operator new(std::size_t size) {
    void* ptr = std::malloc(size);
    if (!ptr) throw std::bad_alloc{};

    std::lock_guard<std::mutex> lock(mtx);
    allocatedMemory[ptr] = size; // 记录分配的内存地址和大小
    std::cout << "分配内存：地址=" << ptr << "，大小=" << size << "字节" << std::endl;
    return ptr;
}

// 重载全局operator delete（普通版本）
void operator delete(void* ptr) noexcept {
    std::lock_guard<std::mutex> lock(mtx);
    if (allocatedMemory.count(ptr)) {
        std::size_t size = allocatedMemory[ptr];
        allocatedMemory.erase(ptr);
        std::cout << "释放内存：地址=" << ptr << "，大小=" << size << "字节" << std::endl;
    }
    std::free(ptr);
}

int main() {
    int* p1 = new int(10);
    int* p2 = new int[5]; // 调用operator new[]

    delete p1;
    // 注意：delete[]调用operator delete[]，这里未重载，使用标准库版本（不会触发监控）
    // 实际使用中需同时重载operator new[]和operator delete[]

    // 程序结束前检查未释放的内存
    std::lock_guard<std::mutex> lock(mtx);
    if (!allocatedMemory.empty()) {
        std::cout << "检测到内存泄漏，未释放的内存块数：" << allocatedMemory.size() << std::endl;
        for (auto& [ptr, size] : allocatedMemory) {
            std::cout << "泄漏地址：" << ptr << "，大小：" << size << "字节" << std::endl;
        }
    }
    return 0;
}

全局重载会影响所有未自定义operator new的类型；
需同时重载operator new[]和operator delete[]以支持数组分配；
通过统计allocatedMemory可以检测内存泄漏，但实际工具（如 Valgrind）更高效。

四、对齐内存分配与 C++17 的`align_val_t`

对于需要高对齐的场景（如 SIMD 指令处理、GPU 数据传输），C++17 引入了align_val_t类型，允许自定义对齐的内存分配。

4.1 对齐的重要性

现代 CPU 对内存对齐有严格要求：

访问未对齐的内存可能导致性能下降（如 x86）或硬件异常（如 ARM）；
SIMD 指令（如 AVX-512）要求数据按 32/64 字节对齐；
GPU 纹理数据通常要求按 256 字节对齐。

4.2 对齐`operator new`的重载

C++17 允许通过align_val_t参数重载operator new，处理特定对齐需求：

#include <iostream>
#include <new>
#include <cstdalign>

// 重载对齐版本的operator new（C++17）
void* operator new(std::size_t size, std::align_val_t align) {
    std::cout << "对齐分配：大小=" << size << "，对齐=" << static_cast<std::size_t>(align) << "字节" << std::endl;
    void* ptr = std::aligned_alloc(static_cast<std::size_t>(align), size);
    if (!ptr) throw std::bad_alloc{};
    return ptr;
}

// 重载对齐版本的operator delete（C++17）
void operator delete(void* ptr, std::align_val_t align) noexcept {
    std::cout << "对齐释放：地址=" << ptr << "，对齐=" << static_cast<std::size_t>(align) << "字节" << std::endl;
    std::free(ptr); // aligned_alloc分配的内存可用free释放
}

// 定义需要32字节对齐的类（C++11 alignas关键字）
class AlignedData {
public:
    alignas(32) int data[8]; // 32字节对齐的int数组（8个int占32字节）
};

int main() {
    AlignedData* data = new AlignedData();
    std::cout << "对象地址：" << data << std::endl;
    std::cout << "地址对齐验证：" << (reinterpret_cast<uintptr_t>(data) % 32 == 0 ? "符合" : "不符合") << std::endl;
    delete data;
    return 0;
}

alignas(32)指定类的对齐要求，new表达式会调用对齐版本的operator new；
std::aligned_alloc是 C11 提供的对齐内存分配函数，C++17 起可用；
对齐分配的内存必须用对应的operator delete释放。

五、常见陷阱与最佳实践

5.1 陷阱 1：内存分配失败的处理

标准库operator new在分配失败时抛std::bad_alloc，但自定义实现需显式处理失败场景：

// 错误示例：未检查malloc返回值
void* operator new(std::size_t size) {
    return std::malloc(size); // malloc失败返回nullptr，但未抛异常，违反标准行为
}

// 正确示例：
void* operator new(std::size_t size) {
    void* ptr = std::malloc(size);
    if (!ptr) throw std::bad_alloc{}; // 必须抛异常或符合nothrow语义
    return ptr;
}

5.2 陷阱 2：`operator delete`的参数匹配

operator delete的size参数（C++14 起可选）必须与operator new的分配大小一致，否则可能导致未定义行为：

class MyClass {
public:
    static void* operator new(std::size_t size) {
        return std::malloc(size + 8); // 多分配8字节用于额外数据
    }
    static void operator delete(void* ptr, std::size_t size) {
        std::free(ptr); // 错误：释放的内存大小应为size+8，但传入的size是sizeof(MyClass)
    }
};

解决方案：若自定义operator new多分配了内存，需在operator delete中手动调整指针（如存储额外数据到多分配的空间中）。

5.3 最佳实践：与智能指针配合

std::unique_ptr和std::shared_ptr支持自定义删除器，可与自定义operator delete结合：

#include <memory>

class CustomAllocator {
public:
    static void* allocate(std::size_t size) { /* 自定义分配 */ }
    static void deallocate(void* ptr) { /* 自定义释放 */ }
};

// 使用unique_ptr管理自定义分配的内存
std::unique_ptr<int, decltype(&CustomAllocator::deallocate)> 
    ptr(static_cast<int*>(CustomAllocator::allocate(sizeof(int))), CustomAllocator::deallocate);

5.4 最佳实践：性能优化建议

小对象使用内存池：减少malloc调用次数，降低内存碎片；
线程安全：多线程环境下，内存池需加锁或使用线程本地存储（TLS）；
对齐优先：对需要高对齐的类型（如图像、SIMD 数据），显式使用对齐operator new；
避免全局重载：全局重载影响范围广，优先使用类特定重载。

六、总结

operator new和operator delete是 C++ 内存管理的 "基础设施"，通过自定义实现可以：

优化高频小对象的分配效率；
实现高对齐内存的精准控制；
监控内存使用，检测泄漏；
与特定场景（如游戏、嵌入式）的内存策略深度整合。

掌握这对操作符的核心逻辑，是成为高级 C++ 开发者的必经之路。在实际项目中，建议结合性能分析工具（如 Perf、Valgrind）验证自定义分配器的效果，避免为优化而引入复杂性。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-06-08，如有侵权请联系 cloudcommunity@tencent.com 删除

工具

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度