讲座主题：C++中的内存分配器——自定义new/delete的魔法之旅

各位程序员小伙伴们，大家好！今天我们要聊一聊C++中一个既神秘又实用的话题——自定义new和delete操作。如果你对内存管理感兴趣，或者想让你的程序更加高效、灵活，那么这次讲座绝对不容错过！

---

开场白：为什么我们需要自定义new/delete？

在C++的世界里，new和delete是内存管理的核心工具。它们负责动态分配和释放内存，帮助我们创建和销毁对象。然而，默认的new和delete并不总是能满足我们的需求。有时候，我们可能需要：

• 优化性能：减少频繁调用系统内存分配器带来的开销。
• 调试方便：记录内存分配的位置，检测内存泄漏。
• 特殊需求：比如使用特定的内存池或堆。

因此，C++允许我们重载new和delete操作符，实现自己的内存分配逻辑。接下来，我们就一起探索这个神奇的功能吧！

---

第一部分：new/delete的基本原理

在深入自定义之前，我们先来了解一下new和delete的工作机制。

1. new的两步曲

当你写new MyClass()时，编译器实际上做了两件事：

1. 调用operator new分配原始内存。
2. 调用构造函数初始化对象。

MyClass* obj = new MyClass();
// 等价于：
void* rawMemory = operator new(sizeof(MyClass));
MyClass* obj = new (rawMemory) MyClass(); // 调用placement new

2. delete的两步曲

同样地，delete obj;也会执行两个步骤：

1. 调用析构函数清理对象。
2. 调用operator delete释放内存。

delete obj;
// 等价于：
obj->~MyClass(); // 调用析构函数
operator delete(obj); // 释放内存

---

第二部分：自定义new/delete的操作

现在，让我们来看看如何自定义new和delete。

1. 全局级别的自定义

如果你想为整个程序提供统一的内存分配策略，可以重载全局的operator new和operator delete。

示例代码

#include <iostream>
#include <cstdlib>

void* operator new(std::size_t size) {
    std::cout << "Custom new called, allocating " << size << " bytesn";
    return std::malloc(size); // 使用标准库的malloc
}

void operator delete(void* ptr) noexcept {
    std::cout << "Custom delete calledn";
    std::free(ptr); // 使用标准库的free
}

class MyClass {
public:
    MyClass() { std::cout << "Constructor calledn"; }
    ~MyClass() { std::cout << "Destructor calledn"; }
};

int main() {
    MyClass* obj = new MyClass();
    delete obj;
    return 0;
}

输出结果

Custom new called, allocating 1 bytes
Constructor called
Destructor called
Custom delete called

小贴士：不要忘记处理noexcept异常规范，否则可能会导致未定义行为。

---

2. 类级别的自定义

如果只想为某个类定制内存分配策略，可以在类内部重载operator new和operator delete。

示例代码

class MyClass {
public:
    void* operator new(std::size_t size) {
        std::cout << "Class-specific new called, allocating " << size << " bytesn";
        return std::malloc(size);
    }

    void operator delete(void* ptr) noexcept {
        std::cout << "Class-specific delete calledn";
        std::free(ptr);
    }

    MyClass() { std::cout << "Constructor calledn"; }
    ~MyClass() { std::cout << "Destructor calledn"; }
};

int main() {
    MyClass* obj = new MyClass();
    delete obj;
    return 0;
}

输出结果

Class-specific new called, allocating 1 bytes
Constructor called
Destructor called
Class-specific delete called

---

3. 自定义内存池

有时候，频繁的内存分配会导致性能瓶颈。我们可以实现一个简单的内存池来优化这种情况。

示例代码

#include <vector>
#include <cstddef>

class MemoryPool {
private:
    std::vector<char*> pool;
    std::size_t blockSize;

public:
    MemoryPool(std::size_t blockSize) : blockSize(blockSize) {}

    void* allocate() {
        char* memory = new char[blockSize];
        pool.push_back(memory);
        return memory;
    }

    void deallocate(void* ptr) {
        for (auto it = pool.begin(); it != pool.end(); ++it) {
            if (*it == static_cast<char*>(ptr)) {
                pool.erase(it);
                delete[] *it;
                break;
            }
        }
    }
};

class MyClass {
private:
    static MemoryPool pool;

public:
    void* operator new(std::size_t size) {
        return pool.allocate();
    }

    void operator delete(void* ptr) noexcept {
        pool.deallocate(ptr);
    }

    MyClass() { std::cout << "Constructor calledn"; }
    ~MyClass() { std::cout << "Destructor calledn"; }
};

MemoryPool MyClass::pool = MemoryPool(100);

int main() {
    MyClass* obj = new MyClass();
    delete obj;
    return 0;
}

注意：这里只是一个简单的示例，实际应用中需要考虑线程安全和内存碎片等问题。

---

第三部分：注意事项与最佳实践

1. 保持一致性：如果你重载了operator new，一定要记得重载对应的operator delete。
2. 避免内存泄漏：确保所有分配的内存都能被正确释放。
3. 考虑多线程环境：在并发场景下，自定义分配器可能需要加锁以保证线程安全。
4. 遵循C++标准：重载new和delete时，务必遵守C++标准中的异常规范（如noexcept）。

---

结语

通过自定义new和delete，我们可以更好地控制程序的内存管理，从而提升性能、简化调试或满足特定需求。虽然这是一项强大的功能，但也需要谨慎使用，以免引入难以排查的问题。

希望今天的讲座能为大家打开一扇新的大门！如果你有任何疑问或想法，欢迎在评论区留言交流。下次见啦，小伙伴们！ 😊