如何重载类的new与成员访问运算符以使用自定义堆？

嘿，这绝对是个超棒的学习实践！既然你已经搞定了自定义堆的Alloc、DeAlloc这些核心函数，要让一个C类用上这套内存管理机制，核心就是重载类的**operator new和operator delete**——这是C里让类绑定自定义分配逻辑的标准玩法，一步步来给你拆解：

第一步：重载类的operator new（分配函数） #

operator new是C++用来分配对象内存的入口，我们要把它的实现替换成调用你的自定义Alloc函数。注意这个函数默认是静态的（即使你不写static关键字，编译器也会自动把它当作静态函数，毕竟创建对象前还没有实例可以调用成员函数）。

示例代码片段：

class MySimpleClass {
public:
    // 重载operator new，接管内存分配
    void* operator new(size_t size) {
        // 调用你的自定义Alloc函数，size是类对象的总大小（编译器自动传入）
        void* allocated_ptr = Alloc(size);
        
        // 保持和标准new一致的行为：分配失败抛出bad_alloc异常（可选，也可以返回nullptr）
        if (!allocated_ptr) {
            throw std::bad_alloc();
        }
        
        return allocated_ptr;
    }

第二步：匹配重载operator delete（释放函数） #

有了自定义分配，必须对应自定义释放，不然内存泄漏就找上门了。同样重载类的operator delete，让它调用你的DeAlloc函数：

// 重载operator delete，接管内存释放
    void operator delete(void* ptr) {
        // 把要释放的指针传给你的DeAlloc函数
        DeAlloc(ptr);
    }
    
    // 如果你的DeAlloc需要知道释放内存的大小，也可以重载带size参数的版本
    void operator delete(void* ptr, size_t size) {
        DeAlloc(ptr); // 这里可以把size也传进去，根据你的DeAlloc实现调整
    }

可选：支持数组分配new[]和delete[] #

如果需要用new[]创建该类的对象数组，还要对应的重载operator new[]和operator delete[]：

// 处理数组分配的operator new[]
    void* operator new[](size_t size) {
        void* ptr = Alloc(size);
        if (!ptr) throw std::bad_alloc();
        return ptr;
    }

    // 处理数组释放的operator delete[]
    void operator delete[](void* ptr) {
        DeAlloc(ptr);
    }

额外考虑：内存对齐（C++17及以上） #

C要求内存分配必须满足对象的对齐要求（比如类里有double成员，就需要8字节对齐）。如果你的Alloc函数还没处理对齐逻辑，在C17及以上可以重载带对齐参数的operator new版本：

#include <new> // 用于std::align_val_t

    void* operator new(size_t size, std::align_val_t align) {
        // 这里需要你的Alloc支持对齐，比如新增一个AllocAligned函数
        void* ptr = AllocAligned(size, static_cast<std::size_t>(align));
        if (!ptr) throw std::bad_alloc();
        return ptr;
    }

    void operator delete(void* ptr, size_t size, std::align_val_t align) {
        // 对应你的对齐释放函数
        DeAllocAligned(ptr);
    }

完整示例代码 #

把这些拼起来，一个完整的测试类大概是这样：

#include <stdexcept>
#include <cstring>
#include <cstdio>

// 假设你的自定义内存管理函数已经实现并声明
extern void* Alloc(size_t size);
extern void DeAlloc(void* ptr);

class MySimpleClass {
private:
    int data;
    char name[20];
public:
    MySimpleClass(int d, const char* n) : data(d) {
        strncpy(name, n, sizeof(name)-1);
        name[sizeof(name)-1] = '\0';
    }

    void print() {
        printf("Data: %d, Name: %s\n", data, name);
    }

    // 重载operator new
    void* operator new(size_t size) {
        void* ptr = Alloc(size);
        if (!ptr) {
            throw std::bad_alloc();
        }
        return ptr;
    }

    // 重载operator delete
    void operator delete(void* ptr) {
        DeAlloc(ptr);
    }

    // 数组版本（可选）
    void* operator new[](size_t size) {
        void* ptr = Alloc(size);
        if (!ptr) throw std::bad_alloc();
        return ptr;
    }

    void operator delete[](void* ptr) {
        DeAlloc(ptr);
    }
};

// 使用示例
int main() {
    try {
        MySimpleClass* obj = new MySimpleClass(42, "TestObj");
        obj->print();
        delete obj; // 调用我们重载的operator delete

        // 数组测试
        MySimpleClass* arr = new MySimpleClass[2]{{10, "Arr1"}, {20, "Arr2"}};
        arr[0].print();
        arr[1].print();
        delete[] arr;
    } catch (const std::bad_alloc& e) {
        printf("Allocation failed: %s\n", e.what());
        return 1;
    }
    return 0;
}

几个关键注意事项 #

• 大小正确性：编译器会自动把类对象的总大小（包括虚函数表指针如果有继承/虚函数的话）传给operator new的size参数，你只需要把这个值原封不动传给Alloc就行。
• 继承场景：如果你的类有派生类，派生类会继承基类的operator new/delete，但如果派生类需要特殊的分配逻辑，也可以自己重载一套。
• 全局 vs 类内重载：如果你想让所有类都用你的自定义堆，可以全局重载operator new/delete，但你现在是针对单个类，类内重载更精准。
• 测试验证：一定要测试分配、释放、合并块的逻辑，比如分配多个对象后逐个释放，检查你的MergeBlocks是否正确合并了空闲块，避免内存碎片或者泄漏。

内容的提问来源于stack exchange，提问作者Adam Sturge