当你想要一个未初始化的缓冲区(例如用作memcpy()的目标)时，使用std::vector与使用raw数组肯定会有性能影响。vector将使用默认构造函数初始化其所有元素。原始数组则不会。

c++规范中std:vector构造函数接受count参数(这是第三种形式):

从各种数据源构造一个新容器，可选地使用用户提供的分配器alloc。

使用默认插入的t的count个实例构造容器。

复杂性

2-3)计数线性

原始数组不会产生这种初始化代价。

注意，使用自定义分配器，可以避免vector元素的“初始化”(即使用默认初始化而不是值初始化)。请看这些问题了解更多细节:

这是c++ 11和Boost下vector::resize(size_type n)的行为吗?容器正确吗? 如何避免std::vector<>来初始化它的所有元素?

假设一个固定长度的数组(例如int* v = new int[1000];vs std::vector<int> v(1000);， v的大小保持固定在1000)，唯一真正重要的性能考虑因素(或者至少对我来说，当我处于类似的困境时)是访问元素的速度。我查了一下STL的向量代码，下面是我的发现:

const_reference
operator[](size_type __n) const
{ return *(this->_M_impl._M_start + __n); }

这个函数肯定会被编译器内联。所以，只要你计划对v做的唯一一件事就是用operator[]访问它的元素，看起来在性能上不应该有任何差别。

为了回应Mehrdad说过的话:

然而，在某些情况下 你仍然需要数组。当 与低级代码(例如: 程序集)或旧的库 需要数组，您可能无法 用向量。

完全不是这样的。向量可以很好地降级为数组/指针，如果你使用:

vector<double> vector;
vector.push_back(42);

double *array = &(*vector.begin());

// pass the array to whatever low-level code you have

这适用于所有主要的STL实现。在下一个标准中，它将被要求工作(即使它现在做得很好)。

应该避免使用带有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提醒我)。

在c++ 11中使用普通数组的理由就更少了。

从最快到最慢，本质上有3种类型的数组，这取决于它们所具有的特性(当然，实现的质量可以使事情变得非常快，即使是列表中的情况3):

静态的，在编译时大小已知。——std::array<T, N> 动态的，运行时大小已知，从不调整大小。这里的典型优化是，如果数组可以直接分配到堆栈中。——不可用。也许在c++ 14之后，在c++ TS中使用dynarray。在C中有vla 动态的，可在运行时调整大小。——std::向量T > <

为1。常量静态数组，在c++ 11中使用std::array<T, N>。

为2。在运行时指定固定大小的数组，但这不会改变它们的大小，在c++ 14中有讨论，但它已经转移到技术规范，最终由c++ 14制成。

为3。std::vector<T>通常会在堆中请求内存。这可能会影响性能，不过可以使用std::vector<T, MyAlloc<T>>来使用自定义分配器改善这种情况。相对于T mytype[] = new mytype[n];你可以调整它的大小它不会像普通数组那样衰减为指针。

使用上面提到的标准库类型来避免数组退化为指针。如果使用相同的特性集，将节省调试时间，并且性能与普通数组完全相同。

我认为最主要的问题不是性能，而是安全性。使用数组可能会犯很多错误(例如，考虑调整大小)，而使用向量可以省去很多麻烦。