C++ `new`/`delete` 的底层实现：内存分配器的定制与hooking

好的，各位观众老爷，欢迎来到“C++内存管理那些事儿”讲座！今天咱们不谈情怀，不讲虚的，就来扒一扒C++ new/delete 的底层实现，以及怎么定制和“hook”它们。放心，咱们尽量说人话，争取让各位听得懂，用得上。

第一幕：C++内存管理的基础——new和delete

首先，我们要明确一点：C++的new和delete，可不只是简单的内存分配和释放。它们背后藏着不少玄机。

• new运算符：
  • 其实分为两步：
    1. 调用operator new()分配原始内存。
    2. 调用构造函数，初始化对象。
• delete运算符：
  • 同样分为两步：
    1. 调用析构函数，清理对象。
    2. 调用operator delete()释放内存。

看起来很简单，对吧？但关键就在于operator new()和operator delete()这两个函数。它们才是真正负责内存分配和释放的“幕后黑手”。

代码示例：

#include <iostream>

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

    void* operator new(size_t size) {
        std::cout << "Custom operator new called, size: " << size << "n";
        void* p = malloc(size); // 使用 malloc 分配内存
        if (!p) throw std::bad_alloc();
        return p;
    }

    void operator delete(void* p) {
        std::cout << "Custom operator delete calledn";
        free(p); // 使用 free 释放内存
    }
};

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

这段代码展示了如何重载类的operator new和operator delete。注意，这里我们用了C语言的malloc和free来分配和释放内存。这是最基础的内存分配方式，也是很多底层内存分配器的基础。

第二幕：默认的内存分配器——谁在干活？

如果你不重载operator new和operator delete，那么C++会使用默认的内存分配器。不同的编译器和操作系统，默认的分配器可能不一样。但一般来说，它们都会基于以下几种策略：

• malloc/free： 最常见，也是最基础的方式。简单粗暴，但效率不高。
• 系统提供的堆管理器： 操作系统会提供一些更高级的堆管理器，比如Windows的HeapAlloc/HeapFree，Linux的brk/sbrk。这些管理器通常会做一些优化，比如内存池、缓存等，提高分配效率。

这些默认的分配器，虽然能满足大部分需求，但也有一些缺点：

• 效率不高： 频繁的小块内存分配，会导致大量的碎片，降低内存利用率。
• 缺乏控制： 无法精细地控制内存分配的行为，比如分配的内存位置、对齐方式等。
• 调试困难： 默认分配器通常不会提供详细的调试信息，比如内存泄漏检测、越界访问检测等。

第三幕：定制内存分配器——自己动手，丰衣足食

为了解决默认分配器的缺点，我们可以定制自己的内存分配器。定制分配器有很多种方式，这里介绍几种常见的：

1. 重载类的operator new和operator delete：

   就像我们在第一个例子里做的那样，可以针对某个类，定制它的内存分配行为。这在需要对某个类的对象进行特殊内存管理时非常有用。

   代码示例：

   #include <iostream>
   #include <vector>
   
   class MyClass {
   private:
       static std::vector<MyClass*> freeList;
       static const int blockSize = 10;
   
   public:
       MyClass() { std::cout << "Constructor calledn"; }
       ~MyClass() { std::cout << "Destructor calledn"; }
   
       void* operator new(size_t size) {
           if (freeList.empty()) {
               // 分配一块大的内存，分割成小块
               MyClass* block = (MyClass*)malloc(size * blockSize);
               if (!block) throw std::bad_alloc();
   
               // 将小块添加到 freeList
               for (int i = 0; i < blockSize; ++i) {
                   freeList.push_back(block + i);
               }
           }
   
           // 从 freeList 中取出一个空闲块
           MyClass* p = freeList.back();
           freeList.pop_back();
           std::cout << "Custom operator new called, using freeListn";
           return p;
       }
   
       void operator delete(void* p) {
           // 将释放的块添加到 freeList
           freeList.push_back(static_cast<MyClass*>(p));
           std::cout << "Custom operator delete called, returning to freeListn";
       }
   };
   
   std::vector<MyClass*> MyClass::freeList;
   
   int main() {
       MyClass* obj1 = new MyClass();
       MyClass* obj2 = new MyClass();
       delete obj1;
       delete obj2;
       return 0;
   }

   这个例子实现了一个简单的内存池。它预先分配一块大的内存，然后分割成小块，放到一个freeList里。每次分配时，就从freeList里取出一个空闲块。释放时，再把块放回freeList。 这种方式可以减少malloc/free的调用次数，提高分配效率。

2. 重载全局的operator new和operator delete：

   可以重载全局的::operator new和::operator delete，这样所有的new和delete都会使用你自定义的分配器。 注意： 这样做会影响整个程序的内存管理，需要谨慎。

   代码示例：

   #include <iostream>
   #include <cstdlib> // for malloc and free
   
   // 重载全局 new
   void* operator new(size_t size) {
       std::cout << "Global operator new called, size: " << size << "n";
       void* p = malloc(size);
       if (!p) throw std::bad_alloc();
       return p;
   }
   
   // 重载全局 delete
   void operator delete(void* p) noexcept {
       std::cout << "Global operator delete calledn";
       free(p);
   }
   
   int main() {
       int* ptr = new int(10);
       delete ptr;
       return 0;
   }

   这段代码重载了全局的operator new和operator delete，简单地包装了malloc和free。 实际应用中，你可以在这里实现更复杂的内存分配逻辑。

3. 使用自定义的分配器类：

   C++标准库提供了一个std::allocator类，可以用来定制容器的内存分配行为。你可以继承std::allocator，实现自己的分配器类，然后把它传递给容器。

   代码示例：

   #include <iostream>
   #include <vector>
   #include <memory> // std::allocator
   
   template <typename T>
   class MyAllocator : public std::allocator<T> {
   public:
       using typename std::allocator<T>::pointer;
       using typename std::allocator<T>::size_type;
   
       MyAllocator() noexcept {}
       template <typename U> MyAllocator(const MyAllocator<U>&) noexcept {}
   
       pointer allocate(size_type n, const void* hint = 0) {
           std::cout << "Custom allocator allocate called, size: " << n * sizeof(T) << "n";
           pointer p = std::allocator<T>::allocate(n, hint); // 调用默认分配器
           return p;
       }
   
       void deallocate(pointer p, size_type n) {
           std::cout << "Custom allocator deallocate calledn";
           std::allocator<T>::deallocate(p, n); // 调用默认分配器
       }
   };
   
   int main() {
       std::vector<int, MyAllocator<int>> vec;
       vec.push_back(1);
       vec.push_back(2);
       return 0;
   }

   这个例子定义了一个MyAllocator类，它继承了std::allocator，并重载了allocate和deallocate方法。在使用std::vector时，我们将MyAllocator作为模板参数传递给std::vector，这样std::vector就会使用我们自定义的分配器来分配内存。

第四幕：内存分配策略——各种姿势，任你选择

定制内存分配器，关键在于选择合适的内存分配策略。这里介绍几种常见的策略：

策略	优点	缺点	适用场景
简单分配	实现简单，易于理解。	效率较低，容易产生碎片。	内存需求不高，对性能要求不高的场景。
内存池	减少malloc/free的调用次数，提高分配效率。	需要预先分配内存，可能造成浪费。	频繁分配和释放大小相同的内存块的场景，比如游戏中的对象池。
Slab分配	专门为内核对象设计的分配策略，效率很高。	实现复杂，不适合通用场景。	Linux内核中，用于分配inode、dentry等内核对象。
buddy system	将内存划分成2的幂次大小的块，分配和释放速度快。	容易产生内部碎片。	Linux内核中，用于分配物理内存页。
jemalloc/tcmalloc	高性能通用内存分配器，针对多线程环境进行了优化。	实现复杂，需要引入额外的库。	对性能要求高的通用场景，比如Web服务器、数据库等。

选择合适的策略，需要根据具体的应用场景来决定。

第五幕：Hooking new/delete——暗度陈仓，瞒天过海

除了定制内存分配器，我们还可以“hook” new/delete，也就是拦截它们的调用，做一些额外的操作。

Hooking的用途：

• 内存泄漏检测： 记录每次new和delete的调用，检查是否有未释放的内存。
• 内存越界访问检测： 在分配的内存块前后添加一些“警戒区”，如果程序访问了警戒区，就说明发生了越界访问。
• 性能分析： 记录每次new和delete的调用时间，分析内存分配的性能瓶颈。

Hooking的方式：

1. 重载全局的operator new和operator delete：

   就像我们之前说的那样，重载全局的operator new和operator delete，可以拦截所有的new和delete调用。

   代码示例：

   #include <iostream>
   #include <cstdlib>
   #include <map>
   
   static std::map<void*, size_t> allocationMap; // 记录分配的内存块
   
   // 重载全局 new
   void* operator new(size_t size) {
       std::cout << "Hooked global operator new called, size: " << size << "n";
       void* p = malloc(size);
       if (!p) throw std::bad_alloc();
       allocationMap[p] = size; // 记录分配的内存块
       return p;
   }
   
   // 重载全局 delete
   void operator delete(void* p) noexcept {
       std::cout << "Hooked global operator delete calledn";
       if (allocationMap.find(p) != allocationMap.end()) {
           allocationMap.erase(p); // 移除记录
       } else {
           std::cerr << "Error: Attempting to delete memory not allocated by hooked new!n";
       }
       free(p);
   }
   
   // 内存泄漏检测函数
   void checkMemoryLeaks() {
       if (!allocationMap.empty()) {
           std::cerr << "Memory leaks detected:n";
           for (const auto& pair : allocationMap) {
               std::cerr << "  Address: " << pair.first << ", Size: " << pair.second << " bytesn";
           }
       } else {
           std::cout << "No memory leaks detected.n";
       }
   }
   
   int main() {
       int* ptr1 = new int(10);
       int* ptr2 = new int[5];
       delete ptr1;
       // 注意：忘记 delete[] ptr2 了，会造成内存泄漏
   
       checkMemoryLeaks(); // 检查内存泄漏
       delete[] ptr2; // 补救，删除 ptr2
       checkMemoryLeaks(); // 再次检查内存泄漏
   
       return 0;
   }

   这段代码重载了全局的operator new和operator delete，并用一个allocationMap来记录分配的内存块。在delete时，会从allocationMap中移除相应的记录。在程序结束时，可以调用checkMemoryLeaks函数，检查是否有未释放的内存。

2. 使用动态链接库（DLL）Hooking：

   可以将operator new和operator delete的Hooking代码放到一个DLL中，然后通过一些技术手段（比如IAT Hooking、Inline Hooking）来拦截new和delete的调用。这种方式更加灵活，可以在不修改源代码的情况下，对程序进行Hooking。

   注意： DLL Hooking比较复杂，需要对操作系统和动态链接机制有深入的了解。

第六幕：注意事项——小心驶得万年船

定制和Hooking new/delete，虽然很强大，但也需要注意一些问题：

• 性能： 定制和Hooking会增加额外的开销，可能会影响程序的性能。
• 兼容性： 不同的编译器和操作系统，对new/delete的实现可能不一样，需要注意兼容性问题。
• 线程安全： 在多线程环境下，需要保证内存分配器的线程安全。
• 异常安全： 在分配内存失败时，需要抛出std::bad_alloc异常。
• 避免递归调用： 在自定义的operator new中，不要直接或间接地调用new运算符，否则会造成无限递归。

总结：

C++的内存管理是一个复杂而重要的领域。通过定制和Hooking new/delete，我们可以更好地控制内存分配的行为，提高程序的性能和稳定性。但是，也需要谨慎使用，避免引入新的问题。

好了，今天的讲座就到这里。希望各位观众老爷有所收获！ 记住：内存管理，是一门艺术！