重载operator new和delete可实现自定义内存管理，如内存池、调试追踪和性能优化；类级别重载仅影响特定类，通过静态成员函数实现，需避免递归调用并确保异常安全；全局重载影响所有new/delete，必须谨慎使用；实现内存池时维护空闲链表，分配时从链表取块，释放时归还，提升频繁小对象分配效率。
在C++中，重载
operator new
和
operator delete
允许我们为特定类或者全局范围定制内存的分配和释放行为。这通常是为了实现自定义的内存管理策略，比如内存池、内存追踪、对齐控制，或者为了优化性能、诊断内存问题。通过这种方式，你可以完全掌控对象在堆上的生命周期起点和终点，而不仅仅是依赖系统默认的
new
和
delete
。
解决方案
重载
operator new
和
operator delete
主要有两种方式：类级别重载和全局重载。
1. 类级别重载
这是最常见且推荐的做法，它只影响特定类的对象分配。当使用
new MyClass
时，如果
MyClass
重载了
operator new
，则会调用该类的版本。
立即学习“C++免费学习笔记（深入）”；
#include #include // For std::malloc, std::freeclass MyClass {public: int data; MyClass(int d = 0) : data(d) { std::cout << "MyClass constructor called for data: " << data << std::endl; } ~MyClass() { std::cout << "MyClass destructor called for data: " << data << std::endl; } // 重载 operator new static void* operator new(size_t size) { std::cout << "Custom MyClass::operator new called for size: " << size << std::endl; // 实际分配内存，这里我们直接调用全局的 new void* ptr = ::operator new(size); // 必须使用 ::operator new 来避免递归 // 或者使用 std::malloc(size); 但要注意异常处理和对齐 if (!ptr) { throw std::bad_alloc(); } std::cout << "Memory allocated at address: " << ptr << std::endl; return ptr; } // 重载 operator delete static void operator delete(void* ptr) noexcept { std::cout << "Custom MyClass::operator delete called for address: " << ptr << std::endl; // 实际释放内存，这里我们直接调用全局的 delete ::operator delete(ptr); // 必须使用 ::operator delete 来避免递归 // 或者使用 std::free(ptr); std::cout << "Memory deallocated." << std::endl; } // 重载 operator new[] (用于数组) static void* operator new[](size_t size) { std::cout << "Custom MyClass::operator new[] called for size: " << size << std::endl; void* ptr = ::operator new[](size); if (!ptr) { throw std::bad_alloc(); } std::cout << "Array memory allocated at address: " << ptr << std::endl; return ptr; } // 重载 operator delete[] (用于数组) static void operator delete[](void* ptr) noexcept { std::cout << "Custom MyClass::operator delete[] called for address: " << ptr << std::endl; ::operator delete[](ptr); std::cout << "Array memory deallocated." << std::endl; }};// 示例用法// int main() {// std::cout << "--- Allocating single MyClass object ---" << std::endl;// MyClass* obj = new MyClass(100);// delete obj;//// std::cout << "n--- Allocating array of MyClass objects ---" << std::endl;// MyClass* arr = new MyClass[3]; // 注意：这里的构造函数调用不会被自定义的 new[] 打印// delete[] arr;//// return 0;// }
2. 全局重载
全局重载会影响所有通过
new
和
delete
进行的内存分配和释放，除非某个类自己重载了它们。这需要非常小心，因为它会改变整个程序的内存管理行为。
#include #include // For std::malloc, std::free// 全局重载 operator newvoid* operator new(size_t size) { std::cout << "Global operator new called for size: " << size << std::endl; void* ptr = std::malloc(size); // 或者 ::malloc(size); if (!ptr) { throw std::bad_alloc(); } return ptr;}// 全局重载 operator deletevoid operator delete(void* ptr) noexcept { std::cout << "Global operator delete called for address: " << ptr << std::endl; std::free(ptr); // 或者 ::free(ptr);}// 全局重载 operator new[]void* operator new[](size_t size) { std::cout << "Global operator new[] called for size: " << size << std::endl; void* ptr = std::malloc(size); if (!ptr) { throw std::bad_alloc(); } return ptr;}// 全局重载 operator delete[]void operator delete[](void* ptr) noexcept { std::cout << "Global operator delete[] called for address: " << ptr << std::endl; std::free(ptr);}// 示例用法// class AnotherClass {// public:// int x;// AnotherClass(int val) : x(val) { std::cout << "AnotherClass constructor: " << x << std::endl; }// ~AnotherClass() { std::cout << "AnotherClass destructor: " << x << std::endl; }// };//// int main() {// std::cout << "--- Global new/delete test ---" << std::endl;// AnotherClass* ac = new AnotherClass(200); // 会调用全局的 operator new// delete ac;//// int* arr = new int[5]; // 会调用全局的 operator new[]// delete[] arr;//// return 0;// }
请注意，在自定义的
operator new
或
operator delete
内部，如果你需要实际分配或释放内存，必须调用全局的
::operator new
、
::operator delete
、
std::malloc
或
std::free
，而不是再次使用
new
或
delete
关键字，否则会导致无限递归。
为什么我们要考虑重载
operator new
operator new
和
operator delete
？
我个人觉得，这玩意儿最香的地方，就是能让你对内存有更细粒度的控制，甚至可以说是“夺回”了内存管理的主导权。我们之所以要考虑重载它们，通常是为了解决一些特定的痛点或者追求极致的优化。
一个很典型的场景是内存池（Memory Pooling）。如果你在一个高性能应用中频繁地创建和销毁大量小对象，比如游戏里的粒子、网络请求里的数据包，每次都向操作系统申请和释放内存（也就是调用全局的
new
和
delete
）开销会很大。操作系统通常会做很多通用性的管理工作，比如寻找合适的空闲块、合并碎片，这些操作相对较慢。而内存池可以预先分配一大块内存，然后自己管理这些小对象的分配和回收。这样一来，分配和释放就变成了简单的指针操作，速度快得多，还能有效减少内存碎片。
再来就是内存调试和追踪。在大型项目中，内存泄漏、越界访问是家常便饭。通过重载
operator new
和
operator delete
，我们可以在每次内存分配和释放时记录下调用栈、分配大小、文件名、行号等信息。这样，当程序崩溃或者发现内存泄漏时，就能迅速定位到问题代码。这比纯粹依赖调试器或操作系统工具要灵活和定制化得多。
还有就是性能优化。有些时候，特定的数据结构或者算法对内存的访问模式有特殊要求，比如需要内存对齐到某个特定的字节边界，或者需要将相关数据放在缓存行中。标准库的
new
和
delete
可能无法满足这些细致的需求。通过重载，我们可以调用底层的
aligned_alloc
或直接与操作系统API交互，确保内存分配符合我们的高性能需求。
当然，也有一些更高级的用法，比如绑定到特定硬件或内存区域，像GPU内存、共享内存或者NUMA架构下的本地内存。这些就不是日常开发能遇到的了，但确实是重载能力的一种体现。总之，核心目的就是：当默认的内存管理机制不够用、效率低下或者无法满足特定需求时，重载就成了我们手中的利器。
重载
operator new
operator new
时有哪些常见的陷阱和注意事项？
我记得有一次，就是因为没注意递归调用，直接把程序跑崩了，那感觉真是一言一言难尽。所以，重载这玩意儿，坑是真不少，得小心翼翼。
首先，最常见的陷阱就是递归调用。如果你在自定义的
operator new
或
operator delete
内部，不小心又使用了
new
或
delete
关键字来分配/释放内存，那恭喜你，你已经成功创建了一个无限递归的黑洞。正确的做法是，如果你需要底层内存分配，必须显式地调用全局的
::operator new
、
::operator delete
，或者更底层的C函数如
std::malloc
和
std::free
。记住那个
::
，它很重要，意味着你是在调用全局命名空间下的版本。
其次，异常安全是另一个大问题。
operator new
在内存分配失败时，标准行为是抛出
std::bad_alloc
异常。如果你使用
std::malloc
，它在失败时返回
nullptr
。那么你的自定义
operator new
就必须检查这个
nullptr
，并在必要时抛出
std::bad_alloc
，以保持与标准行为的一致性。
operator delete
则不同，它不应该抛出异常，因此通常会加上
noexcept
关键字。
再来是
size_t size
参数的含义。
operator new
接收的
size
参数是编译器计算出的，用于存储对象及其所有相关开销（比如虚函数表指针、数组大小信息等）所需的总字节数。你不能简单地认为它就是你类的大小。特别是对于数组
operator new[]
，这个
size
会更大，因为它可能包含了数组元素数量的元数据。你分配的内存必须至少有这么多字节。
内存对齐也是一个不容忽视的细节。
operator new
返回的内存地址必须保证能够正确存储任何类型的对象。这意味着它必须满足所有基本类型的对齐要求，通常是
alignof(std::max_align_t)
。如果你直接使用
std::malloc
，它通常能保证足够的对齐，但如果自己实现更底层的分配，就需要使用
std::aligned_alloc
或其他平台特定的对齐函数。
最后，
operator new
和
operator delete
必须成对出现。如果你重载了
operator new
，那么对应的
operator delete
也应该重载，并且它们的实现逻辑必须是互补的。比如，如果
operator new
从一个内存池中取内存，那么
operator delete
就应该将内存归还到那个内存池。否则，你可能会导致内存泄漏或者双重释放等问题。尤其是在全局重载时，这种成对出现的原则更要严格遵守，因为任何一个环节出错都可能影响整个程序的稳定性。
如何实现一个简单的类级别内存池？
这块儿说起来复杂，但核心思想就是“以空间换时间”，或者说“预先准备好弹药”。实现一个简单的类级别内存池，通常是维护一个空闲内存块的链表（Free List）。当需要分配内存时，就从链表里取；当释放内存时，就把它加回链表。
下面是一个非常简化版的实现思路和代码：
#include #include #include // 考虑线程安全// 假设我们有一个要使用内存池的类class PooledObject {public: int id; double value; PooledObject(int i = 0, double v = 0.0) : id(i), value(v) { // std::cout << "PooledObject constructor: " << id << std::endl; } ~PooledObject() { // std::cout << "PooledObject destructor: " << id << std::endl; } // --- 内存池相关成员 ---private: // 指向下一个空闲块的指针 // 注意：这个指针会占用空闲块的内存，所以它必须能容纳一个指针 // 并且在对象实际被构造时，这部分内存会被对象成员覆盖 PooledObject* nextFreeBlock; static PooledObject* s_freeList; // 空闲链表头 static const size_t BLOCK_SIZE = sizeof(PooledObject); // 每个内存块的大小 static const size_t CHUNK_SIZE = 10; // 每次向系统申请的块数 static std::mutex s_mutex; // 线程安全锁public: // 重载 operator new static void* operator new(size_t size) { if (size != BLOCK_SIZE) { // 如果请求的大小与我们池化对象的大小不符，则回退到全局 new // 这很重要，因为可能存在继承或虚函数表等额外开销 return ::operator new(size); } std::lock_guard lock(s_mutex); // 保证线程安全 if (s_freeList == nullptr) { // 空闲链表为空，需要向系统申请新的内存块 std::cout << "Memory pool exhausted, allocating new chunk of " << CHUNK_SIZE << " objects." << std::endl; // 申请一大块内存，然后将其切割成小块并加入空闲链表 char* newChunk = static_cast(::operator new(BLOCK_SIZE * CHUNK_SIZE)); if (!newChunk) { throw std::bad_alloc(); } for (size_t i = 0; i < CHUNK_SIZE; ++i) { PooledObject* block = reinterpret_cast(newChunk + i * BLOCK_SIZE); block->nextFreeBlock = s_freeList; s_freeList = block; } } // 从空闲链表头部取出一个块 PooledObject* blockToUse = s_freeList; s_freeList = s_freeList->nextFreeBlock; // 移动链表头 std::cout << "Allocated from pool at: " << blockToUse << std::endl; return blockToUse; } // 重载 operator delete static void operator delete(void* ptr) noexcept { if (ptr == nullptr) return; // 简单检查，如果不是我们池化的对象大小，回退到全局 delete // 实际应用中需要更严谨的判断，例如记录池化内存的范围 // 这里只是为了演示，假设所有 PooledObject 都通过池分配 // 如果是从 ::operator new 分配的，则应该用 ::operator delete 释放 // 这是一个简化，实际情况需要更复杂的判断逻辑 // 例如，可以维护一个std::set来记录所有池化分配的地址 // 但那样会增加开销，所以通常是约定好，只有特定大小的对象才走池 // 为了演示，我们假设所有大小为 BLOCK_SIZE 的对象都走池 // 这是一个潜在的bug来源，因为其他类型如果大小碰巧一样，也可能被误处理 // 更好的做法是，在new时标记这块内存是来自池的，或者直接限制只有本类才用池 std::lock_guard lock(s_mutex); // 保证线程安全 PooledObject* blockToReturn = static_cast(ptr); blockToReturn->nextFreeBlock = s_freeList; // 将块放回空闲链表头部 s_freeList = blockToReturn; std::cout << "Returned to pool: " << ptr << std::endl; } // TODO: 考虑 operator new[] 和 operator delete[] 的实现 // 对于内存池，通常只针对单个对象，数组的池化会复杂很多};// 初始化静态成员PooledObject* PooledObject::s_freeList = nullptr;std::mutex PooledObject::s_mutex;// int main() {// std::cout << "--- Testing PooledObject Memory Pool ---" << std::endl;//// std::vector objects;// for (int i = 0; i < 15; ++i) {// objects.push_back(new PooledObject(i, i * 1.1));// }//// for (PooledObject* obj : objects) {// delete obj;// }//// std::cout << "n--- Allocating again to see reuse ---" << std::endl;// PooledObject* obj1 = new PooledObject(100);// PooledObject* obj2 = new PooledObject(200);// delete obj1;// delete obj2;//// return 0;// }
这个例子中，
PooledObject::s_freeList
是核心，它是一个指向
PooledObject
类型（但实际上是空闲内存块）的指针链表。当
new PooledObject
被调用时，
operator new
会检查
s_freeList
。如果链表非空，就取出一个块；如果为空，它会一次性向系统申请一个
CHUNK_SIZE
大小的内存块，然后将这些新块切割并添加到
s_freeList
中。
operator delete
则
以上就是如何重载C++类的operator new和operator delete的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1473984.html
微信扫一扫 
支付宝扫一扫 
