c++ - 使用动态对象分配标准 vector 内容

Question

我有一个 std::vector< MyObject* > my_vector; 这不是空的，我想在其中分配和推送一定数量的 MyObject* 。 我知道要推送的对象数量。有没有比以下更好的方法(优化/更快):

int object_count = 10000;
for(int index = 0; index < object_count; index++)
{
    my_vector.push_back(new MyObject());
}

就像在一次调用 malloc 中为所有 MyObject 分配，然后将结果 memcpy 到 my_vector。 有什么想法吗？

更新 我的问题是调用 new 10000 次。我希望能够分配一大块内存并将内存交换到 my_vector 的末尾。

Answer 1

你可以在 vector 中预留足够的空间，所以它只会分配一次内存。使用 std::unique_ptr<>:

也是一个好习惯

std::vector<std::unqiue_ptr<MyObject> > my_vector;
int object_count = 10000;
my_vector.reserve(object_count);
for(int index = 0; index < object_count; index++)
{
  my_vector.push_back(std::unique_ptr<MyObject>(new MyObject()));
}

更新:如果您不能(或不想)使用 unique_ptr，只需在您的代码中添加 reserve 以预分配内存。

更新 2:据我了解，您想避免在 new MyObject() 中分配内存。一种可能的解决方案如下(不适用于实际应用程序):

// a very simple example
class Pool {
public:
  Pool() : array(new MySpecObjects[10000]), counter(10000); {}
  MySpecObject* get() {
    --counter;
    return array[counter];
  }
  void reset() {
    counter = 10000;
  }
  MySpecObject* array;
  size_t counter;
};

static Pool* getPool() {
  static Pool pool;
  return pool;
}

std::vector<MyObject* > my_vector;
int object_count = 10000;
my_vector.reserve(object_count);
for(int index = 0; index < object_count; index++) {
  my_vector.push_back(getPool().get()));
}

这是一个简化的例子，它不是线程安全的，Pool 会在程序关闭时清除它的内存。它背后的想法类似于flyweight gof pattern。 , see boost for example

更新 3:也许更好的解决方案是使用 intrusive lists这里。然后，您需要做的就是预分配对象 vector :

class MyObject : public boost::intrusive::list_base_hook<> {
  ...
};
// MySpecObject1 and MySpecObject2 inherit MyObject
std::vector<MySpecObject1> objs1(10000);
std::vector<MySpecObject2> objs2(10000);
...

typedef boost::intrusive::list<MyObject> BaseList;

BaseList list;
for (MyObject& ref : objs1) {
  list.push_back(ref);
}
for (MyObject& ref : objs2) {
  list.push_back(ref);
}

请注意，BaseList 不拥有其节点。当你对它执行 push_back 时，list 只是将一个对象链接到现有列表，不执行任何分配。