向量：初始化还是保留？

Question

我知道向量的大小，初始化它的最好方法是什么？

选项 1：

vector<int> vec(3); //in .h
vec.at(0)=var1;     //in .cpp
vec.at(1)=var2;     //in .cpp
vec.at(2)=var3;     //in .cpp

选项 2：

vector<int> vec;     //in .h
vec.reserve(3);      //in .cpp
vec.push_back(var1); //in .cpp
vec.push_back(var2); //in .cpp
vec.push_back(var3); //in .cpp

我猜，Option2 比 Option1 好。是吗？还有其他选择吗？

Answer 1

两种变体具有不同的语义，即您在比较苹果和橙子。

第一个给你一个包含 n 个默认初始化值的向量，第二个变体保留内存，但不初始化它们。

选择更适合您需求的，即在特定情况下什么是“更好”的。

Answer 2

“最好”的方法是：

vector<int> vec = {var1, var2, var3};

可用于支持 C++11 的编译器。

不确定您在头文件或实现文件中执行操作的确切含义。一个可变的全局对我来说是禁忌。如果是类成员，则可以在构造函数初始化列表中进行初始化。

否则，如果您知道要使用多少个项目并且默认值（0 表示 int）会很有用，则通常会使用选项 1。
在这里使用at 意味着你不能保证索引是有效的。这样的情况本身就令人担忧。即使您能够可靠地检测到问题，使用push_back 肯定更简单，并且不必担心索引是否正确。

在选项2的情况下，无论您是否保留内存，通常都会产生零性能差异，因此不保留更简单*。除非向量包含复制成本非常高的类型（并且在 C++11 中不提供快速移动），或者向量的大小将非常巨大。

---

* 来自 Stroustrups C++ Style and Technique FAQ:

人们有时会担心 std::vector 增长的成本 逐渐地。我曾经担心这一点并使用reserve() 优化增长。在测量我的代码并反复拥有 很难真正找到 Reserve() 的性能优势 程序，我停止使用它，除非需要避免 迭代器失效（在我的代码中很少见）。再次：测量之前 你优化。

Answer 3

不知何故，一个完全错误的非答案答案在大约 7 年的时间里一直被接受并获得最高票数。这不是一个苹果和橘子的问题。这不是一个可以用模糊的陈词滥调来回答的问题。

要遵循一个简单的规则：

选项 #1 更快...

...但这可能不是您最关心的问题。

首先，差异很小。其次，随着我们加快编译器优化，差异变得更小。例如，在我的 gcc-5.4.0 上，当运行 3 级编译器优化 (-O3) 时，差异可以说是微不足道的：

所以一般来说，我建议您在遇到这种情况时使用方法#1。但是，如果您不记得哪个是最佳的，则可能不值得努力找出。只需选择其中一个并继续，因为这不太可能导致整个程序明显放缓。

---

这些测试是通过从正态分布中抽样随机向量大小来运行的，然后使用这两种方法对这些大小的向量进行初始化计时。我们保留一个虚拟和变量以确保向量初始化不会被优化，并且我们随机化向量大小和值以努力避免由于分支预测、缓存和其他此类技巧而导致的任何错误。

main.cpp:

/* 
 * Test constructing and filling a vector in two ways: construction with size
 * then assignment versus construction of empty vector followed by push_back
 * We collect dummy sums to prevent the compiler from optimizing out computation
 */

#include <iostream>
#include <vector>

#include "rng.hpp"
#include "timer.hpp"

const size_t kMinSize = 1000;
const size_t kMaxSize = 100000;
const double kSizeIncrementFactor = 1.2;
const int kNumVecs = 10000;

int main() {
  for (size_t mean_size = kMinSize; mean_size <= kMaxSize;
       mean_size = static_cast<size_t>(mean_size * kSizeIncrementFactor)) {
    // Generate sizes from normal distribution
    std::vector<size_t> sizes_vec;
    NormalIntRng<size_t> sizes_rng(mean_size, mean_size / 10.0); 
    for (int i = 0; i < kNumVecs; ++i) {
      sizes_vec.push_back(sizes_rng.GenerateValue());
    }
    Timer timer;
    UniformIntRng<int> values_rng(0, 5);
    // Method 1: construct with size, then assign
    timer.Reset();
    int method_1_sum = 0;
    for (size_t num_els : sizes_vec) {
      std::vector<int> vec(num_els);
      for (size_t i = 0; i < num_els; ++i) {
        vec[i] = values_rng.GenerateValue();
      }
      // Compute sum - this part identical for two methods
      for (size_t i = 0; i < num_els; ++i) {
        method_1_sum += vec[i];
      }
    }
    double method_1_seconds = timer.GetSeconds();
    // Method 2: reserve then push_back
    timer.Reset();
    int method_2_sum = 0;
    for (size_t num_els : sizes_vec) {
      std::vector<int> vec;
      vec.reserve(num_els);
      for (size_t i = 0; i < num_els; ++i) {
        vec.push_back(values_rng.GenerateValue());
      }
      // Compute sum - this part identical for two methods
      for (size_t i = 0; i < num_els; ++i) {
        method_2_sum += vec[i];
      }
    }
    double method_2_seconds = timer.GetSeconds();
    // Report results as mean_size, method_1_seconds, method_2_seconds
    std::cout << mean_size << ", " << method_1_seconds << ", " << method_2_seconds;
    // Do something with the dummy sums that cannot be optimized out
    std::cout << ((method_1_sum > method_2_sum) ? "" : " ") << std::endl;
  }

  return 0;
}

我使用的头文件位于这里：

• rng.hpp
• timer.hpp

Answer 4

虽然您的示例基本相同，但当使用的类型不是 int 时，可能会选择您自己。如果您的类型没有默认构造函数，或者您以后必须重新构造每个元素，我会使用reserve。只是不要落入我所做的陷阱并使用reserve 然后operator[] 进行初始化！

---

构造函数

std::vector<MyType> myVec(numberOfElementsToStart);
int size = myVec.size();
int capacity = myVec.capacity();

在第一种情况下，使用构造函数，size 和 numberOfElementsToStart 将相等，capacity 将大于或等于它们。

将 myVec 视为一个向量，其中包含许多可以访问和修改的 MyType 项目，push_back(anotherInstanceOfMyType) 会将其附加到向量的末尾。

---

预留

std::vector<MyType> myVec;
myVec.reserve(numberOfElementsToStart);
int size = myVec.size();
int capacity = myVec.capacity();

使用reserve 函数时，size 将是0，直到您向数组中添加一个元素并且capacity 将等于或大于numberOfElementsToStart。

将 myVec 想象成一个 空 向量，它可以使用 push_back 没有内存分配 附加到至少第一个 numberOfElementsToStart 元素的新项目。

请注意，push_back() 仍需要内部检查以确保 size 和 increment size，因此您可能需要权衡默认成本建设。

---

列表初始化

std::vector<MyType> myVec{ var1, var2, var3 };

这是初始化向量的附加选项，虽然它仅适用于非常小的向量，但它是用已知值初始化小向量的明确方法。 size 将等于您初始化它的元素数量，capacity 将等于或大于大小。现代编译器可能会优化临时对象的创建并防止不必要的复制。

Answer 5

选项2更好，因为reserve只需要保留内存(3 * sizeof(T))，而第一个选项为容器内的每个单元格调用基类型的构造函数。

对于类似 C 的类型，它可能是相同的。

Answer 6

工作原理

这是特定于实现的，但一般来说，内部的 Vector 数据结构将具有指向元素实际驻留的内存块的指针。默认情况下，GCC 和 VC++ 都分配 0 个元素。所以你可以认为Vector的内存指针默认为nullptr。

当您在选项 1 中调用 vector<int> vec(N); 时，会使用默认构造函数创建 N 个对象。这称为填充构造函数。

当您像选项 2 一样执行vec.reserve(N); after 默认构造函数时，您会得到数据块来保存 3 个元素，但不会像选项 1 那样创建对象。

为什么选择选项 1

如果您知道向量将保留的元素数量，并且您可能会将大部分元素保留为其默认值，那么您可能需要使用此选项。

为什么选择选项 2

这个选项通常比这两个更好，因为它只分配数据块以供将来使用，而不是实际填充从默认构造函数创建的对象。

Answer 7

从长远来看，这取决于元素的使用和数量。

运行下面的程序，了解编译器是如何预留空间的：

vector<int> vec;
for(int i=0; i<50; i++)
{
  cout << "size=" << vec.size()  << "capacity=" << vec.capacity() << endl;
  vec.push_back(i);
}

size 是实际元素的数量，而 capacity 是实现向量的数组的实际大小。 在我的电脑里，直到 10 点，两者都是一样的。但是，当大小为 43 时，容量为 63。根据元素的数量，可能会更好。例如，增加容量可能会很昂贵。

Answer 8

另一种选择是信任您的编译器（tm）并执行push_backs，而无需先调用reserve。当您开始添加元素时，它必须分配一些空间。也许它和你一样好？

拥有完成相同工作的更简单的代码会“更好”。

Answer 9

由于似乎已经过去了 5 年，错误的答案仍然是被接受的答案，而最受好评的答案完全没用（只见树木不见森林），我将添加一个真实的回应。

方法#1：我们将初始大小参数传递给向量，我们称之为n。这意味着向量填充有n 元素，这些元素将被初始化为其默认值。例如，如果向量包含ints，它将用n 零填充。

方法#2：我们首先创建一个空向量。然后我们为n 元素保留空间。在这种情况下，我们永远不会创建 n 元素，因此我们永远不会对向量中的元素执行任何初始化。由于我们计划立即覆盖每个元素的值，因此缺少初始化不会对我们造成任何伤害。另一方面，由于我们整体上做得更少，这将是更好的*选择。

* 更好 - 真正的定义：永远不会更糟。聪明的编译器总有可能找出你想要做什么并为你优化它。

---

结论：使用方法#2。