C++ `std::pmr::monotonic_buffer_resource`：单向增长内存池

好的，各位亲爱的程序员朋友们，欢迎来到今天的C++内存管理小课堂！今天我们要聊的是一个在内存管理界有点“特立独行”的家伙：std::pmr::monotonic_buffer_resource。

开场白：内存管理，一场永无止境的战争

各位都知道，内存管理是C++程序员逃不开的宿命。我们每天都在和 new 和 delete，malloc 和 free 打交道，一不小心就会掉进内存泄漏的陷阱。然而，现代C++为我们提供了更多的选择，std::pmr (Polymorphic Memory Resources) 就是其中一个闪耀的明星。

std::pmr 的目标是让内存分配策略可以像参数一样传递，从而提高代码的灵活性和可维护性。而 std::pmr::monotonic_buffer_resource，则是这个大家族中一个简单而高效的成员。

monotonic_buffer_resource：单行道上的内存分配器

想象一下，你手里拿着一块内存，像一个贪婪的国王，只想不断地往里面塞东西，而且还不允许你把已经塞进去的东西拿出来。这就是 monotonic_buffer_resource 的工作方式：它只能单向增长，分配出去的内存无法单独释放，只能一次性全部释放。

这种“一锤子买卖”的方式，听起来好像很鸡肋，但实际上，在某些特定的场景下，它却能发挥出意想不到的威力。

monotonic_buffer_resource 的优点和缺点

优点	缺点	适用场景
分配速度极快 (通常只是指针移动)	无法单独释放已分配的内存	短生命周期对象、临时数据结构、算法的中间结果等，这些数据结构在同一生命周期内创建和销毁。
简单高效，开销小	内存利用率较低 (如果数据结构大小差异很大)	非常适合帧分配器 (Frame Allocator) 的应用。
避免了复杂的内存碎片问题	必须一次性释放所有内存	对内存分配速度要求极高，但对内存利用率要求不高的场景。
可以配合自定义的内存缓冲，控制内存来源	不适合需要频繁分配和释放内存的场景	构建临时数据结构，例如在编译器或解释器中构建抽象语法树 (AST)。

代码示例：初识 monotonic_buffer_resource

首先，我们需要包含头文件 <memory_resource>：

#include <iostream>
#include <memory_resource>
#include <vector>

int main() {
  // 定义一个大小为 1024 字节的缓冲区
  char buffer[1024];

  // 创建一个 monotonic_buffer_resource，使用 buffer 作为内存池
  std::pmr::monotonic_buffer_resource mbr(buffer, sizeof(buffer));

  // 使用 monotonic_buffer_resource 分配内存
  std::pmr::vector<int> vec(&mbr); // pmr::vector 使用 monotonic_buffer_resource 作为分配器

  // 向 vector 中添加一些元素
  for (int i = 0; i < 10; ++i) {
    vec.push_back(i);
  }

  // 打印 vector 中的元素
  for (int i = 0; i < vec.size(); ++i) {
    std::cout << vec[i] << " ";
  }
  std::cout << std::endl;

  // 注意：不需要手动释放内存，当 mbr 对象销毁时，它所管理的内存也会被释放。
  return 0;
}

在这个例子中，我们首先创建了一个 1024 字节的缓冲区 buffer。然后，我们使用这个缓冲区创建了一个 monotonic_buffer_resource 对象 mbr。接着，我们创建了一个 std::pmr::vector，并指定 mbr 作为其内存分配器。这样，vector 在分配内存时，就会从 mbr 所管理的缓冲区中分配。

深入剖析：monotonic_buffer_resource 的工作原理

monotonic_buffer_resource 内部维护一个指向当前可用内存的指针。每次分配内存时，它只需要将这个指针向前移动相应的字节数即可。由于不需要维护任何额外的元数据，因此分配速度非常快。

让我们来看一个更详细的例子：

#include <iostream>
#include <memory_resource>

int main() {
  char buffer[256];
  std::pmr::monotonic_buffer_resource mbr(buffer, sizeof(buffer));

  // 分配一个 int
  int* int_ptr = static_cast<int*>(mbr.allocate(sizeof(int)));
  *int_ptr = 42;
  std::cout << "Allocated int: " << *int_ptr << std::endl;

  // 分配一个 double
  double* double_ptr = static_cast<double*>(mbr.allocate(sizeof(double)));
  *double_ptr = 3.14159;
  std::cout << "Allocated double: " << *double_ptr << std::endl;

  // 分配一个 char 数组
  char* char_array = static_cast<char*>(mbr.allocate(10));
  strcpy(char_array, "Hello");
  std::cout << "Allocated string: " << char_array << std::endl;

  // 释放所有内存 (通过销毁 mbr 对象)
  return 0;
}

在这个例子中，我们手动使用 mbr.allocate() 分配了 int、double 和 char 数组。注意，我们没有使用 mbr.deallocate() 来释放内存，因为 monotonic_buffer_resource 不支持单独释放已分配的内存。当 mbr 对象销毁时，它所管理的整个缓冲区 buffer 都会被释放。

monotonic_buffer_resource 的高级用法：帧分配器 (Frame Allocator)

monotonic_buffer_resource 最常见的应用场景之一就是实现帧分配器。帧分配器是一种用于管理短生命周期对象的内存分配策略。在每一帧开始时，分配器重置其内部指针，从而释放上一帧分配的所有内存。

#include <iostream>
#include <memory_resource>
#include <vector>

class FrameAllocator {
public:
  FrameAllocator(size_t buffer_size) : buffer_(new char[buffer_size]), buffer_size_(buffer_size), mbr_(buffer_, buffer_size_) {}

  ~FrameAllocator() {
    delete[] buffer_;
  }

  void reset() {
    mbr_.release(); // 重置 monotonic_buffer_resource
    mbr_ = std::pmr::monotonic_buffer_resource(buffer_, buffer_size_); //重新构造
  }

  template <typename T, typename... Args>
  T* allocate(Args&&... args) {
    T* ptr = static_cast<T*>(mbr_.allocate(sizeof(T)));
    new (ptr) T(std::forward<Args>(args)...); // 使用 placement new
    return ptr;
  }

private:
  char* buffer_;
  size_t buffer_size_;
  std::pmr::monotonic_buffer_resource mbr_;
};

int main() {
  FrameAllocator allocator(1024);

  // 帧 1
  allocator.reset();
  int* int_ptr = allocator.allocate<int>(42);
  std::cout << "Frame 1: " << *int_ptr << std::endl;

  // 帧 2
  allocator.reset();
  double* double_ptr = allocator.allocate<double>(3.14159);
  std::cout << "Frame 2: " << *double_ptr << std::endl;

  // 帧 3
  allocator.reset();
  std::vector<int>* vec_ptr = allocator.allocate<std::vector<int>>();
  vec_ptr->push_back(1);
  vec_ptr->push_back(2);
  vec_ptr->push_back(3);
  std::cout << "Frame 3: ";
  for (int i : *vec_ptr) {
    std::cout << i << " ";
  }
  std::cout << std::endl;

  return 0;
}

在这个例子中，我们创建了一个 FrameAllocator 类，它使用 monotonic_buffer_resource 来管理内存。reset() 方法用于重置分配器，释放上一帧分配的所有内存。allocate() 方法用于分配内存，并使用 placement new 来构造对象。

注意事项：release() 函数

monotonic_buffer_resource 提供了一个 release() 函数，用于重置内部指针，但不释放底层缓冲区。这意味着，你可以重复使用同一个 monotonic_buffer_resource 对象，而无需重新分配缓冲区。在上面的 FrameAllocator 例子中，我们使用了 release() 函数来实现帧分配器的重置功能。 如果使用mbr_ = std::pmr::monotonic_buffer_resource(buffer_, buffer_size_); 就需要重新构造。

与其他内存资源比较

std::pmr 库提供了多种内存资源，每种资源都有其自身的优缺点。以下是一些常见的内存资源及其比较：

内存资源	优点	缺点
std::pmr::monotonic_buffer_resource	分配速度快，简单高效，适合短生命周期对象	无法单独释放已分配的内存，内存利用率较低
std::pmr::unsynchronized_pool_resource	可以单独释放已分配的内存，内存利用率较高	分配速度相对较慢，需要维护元数据
std::pmr::synchronized_pool_resource	线程安全，可以在多线程环境中使用	分配速度较慢，开销较大
std::pmr::new_delete_resource	使用 new 和 delete 分配和释放内存，与传统的 C++ 内存管理方式兼容	可能会导致内存碎片，分配速度较慢
std::pmr::null_memory_resource	不分配任何内存，用于测试和调试	无法分配任何内存

总结：monotonic_buffer_resource 的价值

std::pmr::monotonic_buffer_resource 是一种简单而高效的内存分配器，特别适合于管理短生命周期对象。虽然它有一些限制，例如无法单独释放已分配的内存，但只要合理使用，就可以发挥出巨大的威力。

在性能敏感的应用中，例如游戏开发、图形渲染和实时系统，monotonic_buffer_resource 可以帮助你避免复杂的内存管理开销，提高程序的性能。

课后作业：

1. 编写一个程序，使用 monotonic_buffer_resource 实现一个简单的字符串池 (String Pool)。
2. 研究 std::pmr 库中的其他内存资源，并比较它们的优缺点。
3. 尝试将 monotonic_buffer_resource 应用到你自己的项目中，看看是否能提高程序的性能。

好了，今天的课程就到这里。希望大家有所收获，并在实际项目中灵活运用 monotonic_buffer_resource，写出更加高效、健壮的 C++ 代码！ 感谢大家的观看，下次再见！