在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];你可以调整它的大小它不会像普通数组那样衰减为指针。

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

向量使用的内存比数组多一点，因为它们包含数组的大小。它们还会增加程序的硬盘大小，可能还会增加程序的内存占用。这些增加很小，但如果您使用的是嵌入式系统，则可能很重要。尽管这些差异很重要的大多数地方都是使用C而不是c++的地方。

两者之间的性能差异很大程度上取决于实现——如果你比较一个实现得很差的std::vector和一个优化的数组实现，数组会赢，但是反过来，vector会赢……

As long as you compare apples with apples (either both the array and the vector have a fixed number of elements, or both get resized dynamically) I would think that the performance difference is negligible as long as you follow got STL coding practise. Don't forget that using standard C++ containers also allows you to make use of the pre-rolled algorithms that are part of the standard C++ library and most of them are likely to be better performing than the average implementation of the same algorithm you build yourself.

也就是说，以我之见，vector在使用调试STL的调试场景中胜出，因为大多数具有适当调试模式的STL实现至少可以突出/清除人们在使用标准容器时所犯的典型错误。

哦，不要忘记数组和vector共享相同的内存布局，因此您可以使用vector将数据传递给需要基本数组的遗留C或c++代码。但是，请记住，在这种情况下，大多数赌注都是无效的，您将再次处理原始内存。

在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];你可以调整它的大小它不会像普通数组那样衰减为指针。

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

为微优化人员准备的序言

记住:

程序员浪费了大量的时间去思考或担心程序中非关键部分的速度，而当考虑到调试和维护时，这些提高效率的尝试实际上会产生强烈的负面影响。我们应该忘记小的效率，大约97%的时候:过早的优化是万恶之源。但我们不应该错过这关键的3%的机会。”

(感谢metamorphosis的完整引用)

不要使用C数组来代替向量(或任何东西)，因为你认为它更快，因为它应该是低级别的。你可能错了。

使用默认的向量(或者根据需要使用安全的容器)，然后如果你的分析器说这是一个问题，看看你是否可以优化它，要么使用更好的算法，要么改变容器。

话虽如此，我们可以回到最初的问题。

静态/动态数组?

c++数组类比低级C数组表现得更好，因为它们了解自己很多东西，并且可以回答C数组不能回答的问题。他们能够自己打扫卫生。更重要的是，它们通常是使用模板和/或内联编写的，这意味着在调试中出现的大量代码在发布版本中分解为很少或没有代码，这意味着它们与内置的不太安全的竞争没有区别。

总而言之，它分为两类:

动态数组

使用指向malloc-ed/new-ed数组的指针最多和std::vector版本一样快，但安全性要低得多(参见litb的帖子)。

所以使用std::vector。

静态数组

最好使用静态数组:

和std::array版本一样快 更不安全。

所以使用std::array。

未初始化的内存

有时，使用一个向量而不是一个原始缓冲区招致一个可见的成本，因为向量将在构造时初始化缓冲区，而它所取代的代码没有，正如bernie by在他的回答中所说。

如果是这种情况，那么您可以通过使用unique_ptr而不是vector来处理它，或者，如果这种情况在您的代码线中不是例外，实际上编写一个类buffer_owner，它将拥有该内存，并让您轻松安全地访问它，包括调整它的大小(使用realloc?)或任何您需要的奖励。

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