Question

在我的场景中，我有以下几种方式表示的多种操作：

struct Op {
  virtual void Run() = 0;
};

struct FooOp : public Op {
  const std::vector<char> v;
  const std::string s;
  FooOp(const std::vector<char> &v, const std::string &s) : v(v), s(s) {}
  void Run() { std::cout << "FooOp::Run" << '\n'; }
};

// (...)

我的应用程序可以多次运行。在每个过程中，我都想创建许多这样的操作，并且在过程结束时，我可以同时丢弃所有这些操作。因此，我想为这些操作预分配一些内存，并从该内存中分配新的操作。我想出了以下代码：

class FooPool {
public:
  FooPool(int size) {
    foo_pool = new char[size * sizeof(FooOp)]; // what about FooOp alignment?
    cur = 0;
  }

  ~FooPool() { delete foo_pool; }

  FooOp *New(const std::vector<char> &v, const std::string &s) {
    return new (reinterpret_cast<FooOp*>(foo_pool) + cur) FooOp(v,s);
  }

  void Release() {
    for (int i = 0; i < cur; ++i) {
      (reinterpret_cast<FooOp*>(foo_pool)+i)->~FooOp();
    }
    cur = 0;
  }

private:
  char *foo_pool;
  int cur;
};

这似乎可行，但我敢肯定我需要以某种方式注意FooOp的对齐方式。而且，由于操作不是POD，我什至不确定这种方法是否可行。

我的方法有缺陷吗？（最有可能）
有什么更好的方法？
是否可以使用unique_ptr s回收现有内存？

谢谢！

Answer 1

我认为这段代码将具有类似的性能特征，而无需您弄乱新的和对齐的存储位置。

class FooPool {
public:
    FooPool(int size) {
        pool.reserve(size);
    }

    FooOp* New(const std::vector<char>& v, const std::string& s) {
        pool.emplace_back(v, s); // in c++17: return pool.emplace_back etc. etc.
        return &pool.back();
    }

    void Release() {
        pool.clear();
    }

private:
    std::vector<FooOp> pool;
}

这里的关键思想是您的FooPool本质上是在std::vector的工作范围内。

如何创建非POD类型的连续内存池？

1 个答案: