重载operator new和delete可实现自定义内存管理，如内存池、调试追踪和性能优化；类级别重载仅影响特定类，通过静态成员函数实现，需避免递归调用并确保异常安全；全局重载影响所有new/delete，必须谨慎使用；实现内存池时维护空闲链表，分配时从链表取块，释放时归还，提升频繁小对象分配效率。
在C++中，重载
operator new
operator delete
new
delete
重载
operator new
operator delete
1. 类级别重载
这是最常见且推荐的做法，它只影响特定类的对象分配。当使用
new MyClass
MyClass
operator new
立即学习“C++免费学习笔记（深入）”；
#include <iostream>
#include <cstdlib> // For std::malloc, std::free
class 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 <iostream>
#include <cstdlib> // For std::malloc, std::free
// 全局重载 operator new
void* 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 delete
void 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 delete
我个人觉得，这玩意儿最香的地方，就是能让你对内存有更细粒度的控制，甚至可以说是“夺回”了内存管理的主导权。我们之所以要考虑重载它们，通常是为了解决一些特定的痛点或者追求极致的优化。
一个很典型的场景是内存池（Memory Pooling）。如果你在一个高性能应用中频繁地创建和销毁大量小对象，比如游戏里的粒子、网络请求里的数据包，每次都向操作系统申请和释放内存（也就是调用全局的
new
delete
再来就是内存调试和追踪。在大型项目中，内存泄漏、越界访问是家常便饭。通过重载
operator new
operator delete
还有就是性能优化。有些时候，特定的数据结构或者算法对内存的访问模式有特殊要求，比如需要内存对齐到某个特定的字节边界，或者需要将相关数据放在缓存行中。标准库的
new
delete
aligned_alloc
当然，也有一些更高级的用法，比如绑定到特定硬件或内存区域，像GPU内存、共享内存或者NUMA架构下的本地内存。这些就不是日常开发能遇到的了，但确实是重载能力的一种体现。总之，核心目的就是：当默认的内存管理机制不够用、效率低下或者无法满足特定需求时，重载就成了我们手中的利器。
operator new
我记得有一次，就是因为没注意递归调用，直接把程序跑崩了，那感觉真是一言一言难尽。所以，重载这玩意儿，坑是真不少，得小心翼翼。
首先，最常见的陷阱就是递归调用。如果你在自定义的
operator new
operator delete
new
delete
::operator new
::operator delete
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 <iostream>
#include <vector>
#include <mutex> // 考虑线程安全
// 假设我们有一个要使用内存池的类
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<std::mutex> 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<char*>(::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<PooledObject*>(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<std::mutex> lock(s_mutex); // 保证线程安全
PooledObject* blockToReturn = static_cast<PooledObject*>(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<PooledObject*> 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的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
750
收藏
