c++ vector 自定义内存分配器到栈内存

在 C++ 中，可以使用自定义内存分配器来控制 std::vector 的内存分配行为。例如，可以使用自定义内存分配器将 std::vector 的内存分配到栈上，而不是堆上。

要实现这个目的，需要自定义一个内存分配器类，然后在 std::vector 的模板参数中指定使用这个内存分配器类。自定义内存分配器类需要实现以下接口：

class MyAllocator {
public:
  using value_type = T;
  using pointer = T*;
  using const_pointer = const T*;
  using reference = T&;
  using const_reference = const T&;

  MyAllocator() noexcept {}
  template <class U> MyAllocator(const MyAllocator<U>&) noexcept {}
  ~MyAllocator() noexcept {}

  pointer allocate(std::size_t n);
  void deallocate(pointer p, std::size_t n);
  template <class U, class... Args>
  void construct(U* p, Args&&... args);
  void destroy(pointer p);
};

其中，allocate 函数用于分配内存，deallocate 函数用于释放内存，construct 函数用于在指定的内存位置构造对象，destroy 函数用于析构指定的对象。

下面是一个示例，它使用栈内存作为 std::vector 的内存分配器：

template <typename T, std::size_t N>
class StackAllocator
{
public:
    using value_type = T;
    using pointer = T *;
    using const_pointer = const T *;
    using reference = T &;
    using const_reference = const T &;

    StackAllocator() noexcept {}
    template <class U>
    StackAllocator(const StackAllocator<U, N> &) noexcept {}
    ~StackAllocator() noexcept {}

    pointer allocate(std::size_t n)
    {
        if (n > max_size())
        {
            throw std::bad_alloc();
        }
        if (p_ + n > end_)
        {
            throw std::bad_alloc();
        }
        auto result = p_;
        p_ += n;
        return result;
    }

    void deallocate(pointer p, std::size_t n) {}

    template <class U, class... Args>
    void construct(U *p, Args &&...args)
    {
        new (p) U(std::forward<Args>(args)...);
    }

    void destroy(pointer p) { p->~T(); }

    std::size_t max_size() const noexcept { return N; }

private:
    alignas(alignof(T)) char buf_[N * sizeof(T)];
    pointer p_ = reinterpret_cast<pointer>(buf_);
    pointer end_ = reinterpret_cast<pointer>(buf_ + sizeof(buf_));
};

template <typename T, typename U, std::size_t N>
bool operator==(const StackAllocator<T, N> &, const StackAllocator<U, N> &)
{
    return true;
}

template <typename T, typename U, std::size_t N>
bool operator!=(const StackAllocator<T, N> &lhs, const StackAllocator<U, N> &rhs)
{
    return !(lhs == rhs);
}

int main()
{
    std::vector<int, StackAllocator<int, 10>> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(3);
    return 0;
}

在这个示例中，我们定义了一个名为 StackAllocator 的内存分配器类，它使用一个固定大小的栈内存作为内存池。然后，我们使用这个内存分配器类来定义一个 std::vector，并在 std::vector 中插入三个整数。