通过重载new和delete，MyClass使用自定义内存池管理对象分配，提升性能并监控内存使用，数组操作则回退到全局分配器。
在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";
}
}};
重载 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的对象创建和销毁会使用自定义内存池，而数组操作仍走默认路径。你可以根据需要扩展支持
new[]和
delete[]的池化管理。
基本上就这些。自定义
new和
delete是实现高效内存管理的重要手段，尤其适用于频繁创建销毁对象的场景。
