关于杜里的贡献和我自己的测量。

结论是整数数组比整数向量快(在我的例子中是5倍)。然而，对于更复杂/未对齐的数据，数组和向量的速度大致相同。

STL is a heavily optimized library. In fact, it's even suggested to use STL in games where high performance might be needed. Arrays are too error prone to be used in day to day tasks. Today's compilers are also very smart and can really produce excellent code with STL. If you know what you are doing, STL can usually provide the necessary performance. For example by initializing vectors to required size (if you know from start), you can basically achieve the array performance. However, there might be cases where you still need arrays. When interfacing with low level code (i.e. assembly) or old libraries that require arrays, you might not be able to use vectors.

下面是简单的测试:

c++数组vs Vector性能测试说明

与“对向量和数组/指针的基本索引、解引用和增量操作生成的汇编代码的比较”的结论相矛盾。

数组和向量之间一定有区别。测试是这么说的…试试吧，代码就在那里……

应该避免使用带有new的c++数组(即使用动态数组)。这里有一个问题，你必须跟踪大小，你需要手动删除它们，做各种各样的家务。

在堆栈上使用数组也是不鼓励的，因为您没有范围检查，并且传递数组将丢失关于其大小的任何信息(数组到指针的转换)。在这种情况下，应该使用std::array，它将c++数组包装在一个小类中，并提供一个size函数和迭代器来迭代它。

现在，std::vector vs.原生c++数组(取自互联网):

// Comparison of assembly code generated for basic indexing, dereferencing, 
// and increment operations on vectors and arrays/pointers.

// Assembly code was generated by gcc 4.1.0 invoked with  g++ -O3 -S  on a 
// x86_64-suse-linux machine.

#include <vector>

struct S
{
  int padding;

  std::vector<int> v;
  int * p;
  std::vector<int>::iterator i;
};

int pointer_index (S & s) { return s.p[3]; }
  // movq    32(%rdi), %rax
  // movl    12(%rax), %eax
  // ret

int vector_index (S & s) { return s.v[3]; }
  // movq    8(%rdi), %rax
  // movl    12(%rax), %eax
  // ret

// Conclusion: Indexing a vector is the same damn thing as indexing a pointer.

int pointer_deref (S & s) { return *s.p; }
  // movq    32(%rdi), %rax
  // movl    (%rax), %eax
  // ret

int iterator_deref (S & s) { return *s.i; }
  // movq    40(%rdi), %rax
  // movl    (%rax), %eax
  // ret

// Conclusion: Dereferencing a vector iterator is the same damn thing 
// as dereferencing a pointer.

void pointer_increment (S & s) { ++s.p; }
  // addq    $4, 32(%rdi)
  // ret

void iterator_increment (S & s) { ++s.i; }
  // addq    $4, 40(%rdi)
  // ret

// Conclusion: Incrementing a vector iterator is the same damn thing as 
// incrementing a pointer.

注意:如果你用new分配数组，并分配非类对象(如纯int)或没有用户定义的构造函数的类，并且你不想让你的元素初始化，使用new-allocated数组可以有性能优势，因为std::vector在构造时将所有元素初始化为默认值(例如int为0)(感谢@bernie提醒我)。

可能会有一些边缘情况，你在内联函数中有一个向量访问在内联函数中，你已经超出了编译器将内联的范围，它将强制函数调用。这种情况太罕见了，不值得担心——总的来说，我同意litb的观点。

我很惊讶居然没有人提到这一点——不要担心性能，直到它被证明是一个问题，然后进行基准测试。

向量是底层的数组。 性能是一样的。

一个可能会遇到性能问题的地方是，vector的大小一开始就不正确。

当一个vector容器被填充时，它将调整自身的大小，这可能意味着，一个新的数组分配，然后是n个复制构造函数，然后是大约n个析构函数调用，然后是一个数组删除。

如果你的构造/销毁是昂贵的，你最好让向量的正确大小开始。

有一种简单的方法可以证明这一点。创建一个简单的类，显示它何时被构造/销毁/复制/赋值。创建一个这些东西的向量，并开始将它们推到向量的后端。当向量被填充时，随着向量大小的调整，将会有一连串的活动。然后再试一次，将向量大小调整为预期的元素数量。你会发现其中的不同。