通过重载new和delete，MyClass使用自定义内存池管理对象分配，提升性能并监控内存使用，数组操作则回退到全局分配器。
在C++中，通过重载
new和
delete运算符，可以实现自定义内存分配行为。这在需要优化性能、监控内存使用或使用特定内存池的场景中非常有用。下面是一个简单的实例，展示如何在类级别重载
new和
delete，实现自定义内存分配器。
自定义内存池类
我们先定义一个简单的内存池，用于管理固定大小的内存块分配。
#include#include #include const size_t POOL_SIZE = 1024; const size_t BLOCK_SIZE = sizeof(int);
class MemoryPool { char pool[POOL_SIZE * BLOCK_SIZE]; bool blocks[POOL_SIZE] = {false}; // 标记块是否已分配
public: void 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 BLOCK_SIZE; } } std::cout << "Out of memory in pool\n"; return nullptr; }
void deallocate(void* ptr) { if (ptr youjiankuohaophpcn= pool && ptr zuojiankuohaophpcn pool + POOL_SIZE * BLOCK_SIZE) { size_t index = ((char*)ptr - pool) / BLOCK_SIZE; if (index zuojiankuohaophpcn POOL_SIZE && blocks[index]) { blocks[index] = false; std::cout zuojiankuohaophpcnzuojiankuohaophpcn "Freed block " zuojiankuohaophpcnzuojiankuohaophpcn index zuojiankuohaophpcnzuojiankuohaophpcn " back to pool\n"; } } else { std::cout zuojiankuohaophpcnzuojiankuohaophpcn "Ignoring delete: not from pool\n"; } }};
重载 new 和 delete 运算符
在目标类中重载
new和
delete，使其使用上面定义的内存池。
立即学习“C++免费学习笔记（深入）”；
class MyClass {
static MemoryPool pool;
int value;
public:
MyClass(int v) : value(v) {
std::cout << "MyClass constructed with value " << value << "\n";
}
~MyClass() {
std::cout zuojiankuohaophpcnzuojiankuohaophpcn "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 zuojiankuohaophpcnzuojiankuohaophpcn "Array new called, using global allocator\n";
return ::operator new[](size);
}
void operator delete[](void* ptr) noexcept {
std::cout zuojiankuohaophpcnzuojiankuohaophpcn "Array delete called\n";
::operator delete[](ptr);
}};
// 静态成员定义
MemoryPool MyClass::pool;
测试代码
编写主函数测试自定义内存分配行为。
int main() {
std::cout << "=== Testing custom allocator ===\n";
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的对象创建和销毁会使用自定义内存池，而数组操作仍走默认路径。你可以根据需要扩展支持
new[]和
delete[]的池化管理。
基本上就这些。自定义
new和
delete是实现高效内存管理的重要手段，尤其适用于频繁创建销毁对象的场景。
