在向量中分配临时元素（知道最大数量）的最快方法？

Question

在一个函数中，我需要将一些整数存储在一个向量中。该函数被多次调用。我知道它们小于 10，但是对于函数的每次调用，这个数字都是可变的。怎样选择才能有更好的表现？

在示例中我发现：

std::vector<int> list(10)
std::vector<int>::iterator it=list.begin();
unsigned int nume_of_elements_stored;

for ( ... iterate on some structures ... ){
    if (... a specific condition ...){
         *it= integer from structures ;
         it++;
         nume_of_elements_stored++;
     }
}

慢于：

std::vector<int> list;
unsigned int num_of_elements_stored(0);

for ( ... iterate on some structures ... ){
    if (... a specific condition ...){
         list.push_back( integer from structures )
     }
}
num_of_elements_stored=list.size();

Answer 1

我要在这里走一条非常不酷的路线。冒着被钉在十字架上的风险，我建议std::vector 在这里不是很好。一个例外是，如果您对内存分配器很幸运，并通过分配器获得了创建和销毁通常无法提供的大量 vectors 的时间局部性。

等等！

在人们杀了我之前，我想说vector 很棒，一般来说，它是可用的最全面的数据结构之一。但是，当您查看这样的热点时（希望使用分析器），由于在紧密循环中反复创建了一堆很小的vectors，这就是vector 的这种直接使用可以咬你的地方。

问题在于它是一个堆分配结构（基本上是一个动态数组），当我们处理大量像这样的小数组时，我们真的想在顶部使用经常缓存的内存尽可能便宜地分配/释放的堆栈。

缓解这种情况的一种方法是在重复调用中重复使用相同的向量。将其存储在外部调用函数的范围内并通过引用传递它，clear 它，执行您的push_backs，冲洗并重复。值得注意的是，clear 不会释放向量中的任何内存，因此它保留了之前的容量（当我们想要重用相同的内存并播放时间局部性时，这很有用）。

但是在这里我们可以玩到那个堆栈。作为一个简化的例子（使用 C 风格的代码，在 C++ 中不是很 kosher，甚至不关心异常安全，但更容易说明）：

int stack_mem[32];
int num = 0;
int cap = 32;
int* ptr = stack_mem;

for ( ... iterate on some structures ... )
{
    if (... a specific condition ...)
    {
         if (num == cap)
         {
             cap *= 2;
             int* new_ptr = static_cast<int*>(malloc(cap * sizeof(int)));
             memcpy(new_ptr, ptr, num * sizeof(int));
             if (ptr != stack_mem)
                  free(ptr);
             ptr = new_ptr;
         }
         ptr[num++] = your_int;
    }
}

if (ptr != stack_mem)
     free(ptr);

当然，如果你使用这样的东西，你应该将它正确地包装在一个可重用的类模板中，该模板进行边界检查，不使用memcpy，具有异常安全性，正式的 push_back 方法，emplace_back，复制 ctor ，移动 ctor，交换，可能是填充 ctor，范围 ctor，擦除，范围擦除，插入，范围插入，大小，空，迭代器/开始/结束，使用放置新以避免需要复制分配或默认 ctor 等。

解决方案在N <= 32 时使用堆栈（可以使用适合您的常见情况需要的不同数字），然后在超出时切换到堆。这允许它有效地处理您的常见案例场景，但也不仅仅是在那些罕见的案例场景中，N 在某些病理情况下可能很大。这使得它在某种程度上可以与 C 中的可变长度数组相媲美（我实际上希望我们在 C++ 中拥有这一点，至少在std::dynarray 可用之前），但没有堆栈溢出倾向，因为它在极少数情况下切换到堆。

我将所有这些符合标准的形式应用到一个基于这个想法的结构和一个接受<T, FixedN> 的类模板中，现在使用它几乎和vector 一样多，因为我使用 teeny 处理过很多这样的案例重复创建的数组在绝大多数常见情况下应该适合堆栈（但总是具有那些极其罕见的例外可能性）。它消除了我在地图上与内存相关的许多分析器热点。

...但是应用这个基本想法可能会给您带来很大的提升。如果在您的测量中得到回报，您可以应用上述那种将其包装到保留 C++ 对象语义的安全容器中的努力，我认为在您的情况下应该相当多。

Answer 2

我可能会选择一种中间立场：

std::vector<int> list;
list.reserve(10);

...其余的可能与您的第二个版本非常相似。然而，老实说，这是否真的会产生很大的影响可能还有待商榷。

Answer 3

如果你使用静态向量，它只会被分配一次。 第一个示例运行速度较慢，因为它每次调用都会分配和销毁向量。