C++自定义内存分配器重载new运算符实例-C++-PHP中文网

C++自定义内存分配器重载new运算符实例

P粉602998670

发布： 2025-08-26 12:20:02

原创

354人浏览过

通过重载new和delete，MyClass使用自定义内存池管理对象分配，提升性能并监控内存使用，数组操作则回退到全局分配器。

c++自定义内存分配器重载new运算符实例

在C++中，通过重载

new

登录后复制

和

delete

登录后复制

运算符，可以实现自定义内存分配行为。这在需要优化性能、监控内存使用或使用特定内存池的场景中非常有用。下面是一个简单的实例，展示如何在类级别重载

new

登录后复制

和

delete

登录后复制

，实现自定义内存分配器。

自定义内存池类

我们先定义一个简单的内存池，用于管理固定大小的内存块分配。

#include <iostream>
#include <cstdlib>
#include <new>
<p>const size_t POOL_SIZE = 1024;
const size_t BLOCK_SIZE = sizeof(int);</p><p>class MemoryPool {
char pool[POOL_SIZE * BLOCK_SIZE];
bool blocks[POOL_SIZE] = {false}; // 标记块是否已分配</p><p>public:
void<em> allocate() {
for (size_t i = 0; i < POOL_SIZE; ++i) {
if (!blocks[i]) {
blocks[i] = true;
std::cout << "Allocated block " << i << " from pool\n";
return pool + i </em> BLOCK_SIZE;
}
}
std::cout << "Out of memory in pool\n";
return nullptr;
}</p><pre class='brush:php;toolbar:false;'>void deallocate(void* ptr) {
    if (ptr >= pool && ptr < pool + POOL_SIZE * BLOCK_SIZE) {
        size_t index = ((char*)ptr - pool) / BLOCK_SIZE;
        if (index < POOL_SIZE && blocks[index]) {
            blocks[index] = false;
            std::cout << "Freed block " << index << " back to pool\n";
        }
    } else {
        std::cout << "Ignoring delete: not from pool\n";
    }
}

登录后复制

};

琅琅配音

全能AI配音神器

208

查看详情

重载 new 和 delete 运算符

在目标类中重载

new

登录后复制

和

delete

登录后复制

，使其使用上面定义的内存池。

立即学习“C++免费学习笔记（深入）”；

class MyClass {
    static MemoryPool pool;
    int value;
<p>public:
MyClass(int v) : value(v) {
std::cout << "MyClass constructed with value " << value << "\n";
}</p><pre class='brush:php;toolbar:false;'>~MyClass() {
    std::cout << "MyClass destroyed\n";
}

// 重载 new
void* operator new(size_t size) {
    if (size != sizeof(MyClass)) {
        return ::operator new(size); // 使用全局 new
    }
    void* ptr = pool.allocate();
    if (!ptr) throw std::bad_alloc();
    return ptr;
}

// 重载 delete
void operator delete(void* ptr) noexcept {
    if (ptr == nullptr) return;
    pool.deallocate(ptr);
}

// 重载数组版本（可选）
void* operator new[](size_t size) {
    std::cout << "Array new called, using global allocator\n";
    return ::operator new[](size);
}

void operator delete[](void* ptr) noexcept {
    std::cout << "Array delete called\n";
    ::operator delete[](ptr);
}

登录后复制

};

// 静态成员定义 MemoryPool MyClass::pool;

测试代码

编写主函数测试自定义内存分配行为。

int main() {
    std::cout << "=== Testing custom allocator ===\n";
<pre class='brush:php;toolbar:false;'>MyClass* obj1 = new MyClass(10);
MyClass* obj2 = new MyClass(20);

delete obj1;
delete obj2;

// 测试数组（使用全局分配）
MyClass* arr = new MyClass[3]{1, 2, 3};
delete[] arr;

return 0;

登录后复制

}

输出示例：

=== Testing custom allocator ===
Allocated block 0 from pool
MyClass constructed with value 10
Allocated block 1 from pool
MyClass constructed with value 20
MyClass destroyed
Freed block 0 back to pool
MyClass destroyed
Freed block 1 back to pool
Array new called, using global allocator
MyClass constructed with value 1
MyClass constructed with value 2
MyClass constructed with value 3
Array delete called
MyClass destroyed
MyClass destroyed
MyClass destroyed

登录后复制

通过这种方式，MyClass的对象创建和销毁会使用自定义内存池，而数组操作仍走默认路径。你可以根据需要扩展支持