C++ 数组与向量

Question

当使用 C++ 向量时，花费的时间是 718 毫秒， 而当我使用 Array 时，时间几乎是 0 毫秒。

为什么会有这么大的性能差异？

int _tmain(int argc, _TCHAR* argv[])
{
const int size = 10000; 
clock_t start, end; 
start = clock();
vector<int> v(size*size); 
for(int i = 0; i < size; i++)
{  
    for(int j = 0; j < size; j++)
    {   
        v[i*size+j] = 1;  
    } 
} 
end = clock();
cout<< (end - start)
    <<" milliseconds."<<endl; // 718 milliseconds

int f = 0;
start = clock(); 
int arr[size*size]; 
for(int i = 0; i < size; i++)
{  
    for(int j = 0; j < size; j++)
    {   
        arr[i*size+j] = 1;  
    } 
} 
end = clock();
cout<< ( end - start)
    <<" milliseconds."<<endl; // 0 milliseconds
return 0;
}

Answer 1

您的数组 arr 是在堆栈上分配的，即编译器在编译时已计算出必要的空间。在方法的开头，编译器会插入一个汇编语句，如

sub esp, 10000*10000*sizeof(int)

这意味着堆栈指针 (esp) 减少了 10000 * 10000 * sizeof(int) 字节，以便为 10000² 个整数的数组腾出空间。这个操作几乎是即时的。

向量是堆分配的，堆分配的成本要高得多。当向量分配所需的内存时，它必须向操作系统请求一块连续的内存，而操作系统必须执行大量工作才能找到这块内存。

正如 Andreas 在 cmets 中所说，你所有的时间都花在了这一行：

vector<int> v(size*size); 

访问循环内的向量与访问数组一样快。

有关其他概述，请参见例如

• [What and where are the stack and heap?

• [http://computer.howstuffworks.com/c28.htm][2]

• [http://www.cprogramming.com/tutorial/virtual_memory_and_heaps.html][3]

编辑：

在所有关于性能优化和编译器设置的 cmets 之后，我今天早上做了一些测量。我必须设置size=3000，所以我用大约十分之一的原始条目进行了测量。所有测量均在 2.66 GHz Xeon 上进行：

1. 使用 Visual Studio 2008 中的调试设置（无优化、运行时检查和调试运行时），向量测试耗时 920 毫秒，而阵列测试耗时 0 毫秒。

   98,48% 的总时间花在了vector::operator[]，也就是说，时间确实花在了运行时检查上。

2. 在完全优化的情况下，向量测试需要 56 毫秒（原始条目数的十分之一），而数组则需要 0 毫秒。

   向量 ctor 需要 总 应用程序运行时间的 61,72%。

所以我猜每个人都是正确的，具体取决于所使用的编译器设置。 OP 的时序建议优化构建或没有运行时检查的 STL。

一如既往，士气是：首先配置文件，然后优化。

Answer 2

如果您使用 Microsoft 编译器进行编译，为了公平比较，您需要通过定义 _SECURE_SCL=0 和 _HAS_ITERATOR_DEBUGGING=0 来关闭迭代器安全检查和迭代器调试。

其次，您使用的构造函数将每个向量值初始化为零，并且在填充数组之前不会将数组设置为零。所以你要遍历向量两次。

试试：

vector<int> v; 
v.reserve(size*size);

Answer 3

为了公平比较，我认为以下内容应该是合适的：

#include <sys/time.h>
#include <vector>
#include <iostream>
#include <algorithm>
#include <numeric>


int main()
{
  static size_t const size = 7e6;

  timeval start, end;
  int sum;

  gettimeofday(&start, 0);
  {
    std::vector<int> v(size, 1);
    sum = std::accumulate(v.begin(), v.end(), 0);
  }
  gettimeofday(&end, 0);

  std::cout << "= vector =" << std::endl
        << "(" << end.tv_sec - start.tv_sec
        << " s, " << end.tv_usec - start.tv_usec
        << " us)" << std::endl
        << "sum = " << sum << std::endl << std::endl;

  gettimeofday(&start, 0);
  int * const arr =  new int[size];
  std::fill(arr, arr + size, 1);
  sum = std::accumulate(arr, arr + size, 0);
  delete [] arr;
  gettimeofday(&end, 0);

  std::cout << "= Simple array =" << std::endl
        << "(" << end.tv_sec - start.tv_sec
        << " s, " << end.tv_usec - start.tv_usec
        << " us)" << std::endl
        << "sum = " << sum << std::endl << std::endl;
}

在这两种情况下，都会执行动态分配和解除分配，以及对元素的访问。

在我的 Linux 机器上：

$ g++ -O2 foo.cpp 
$ ./a.out 
= vector =
(0 s, 21085 us)
sum = 7000000

= Simple array =
(0 s, 21148 us)
sum = 7000000

std::vector<> 和数组案例的性能相当。关键是，如果您的代码结构合理，std::vector<> 可以与简单数组一样快。

---

在相关说明中，关闭优化在这种情况下会产生巨大的影响：

$ g++ foo.cpp 
$ ./a.out 
= vector =
(0 s, 120357 us)
sum = 7000000

= Simple array =
(0 s, 60569 us)
sum = 7000000

Neil 和 jalf 等人的许多优化断言是完全正确的。

HTH！

编辑：更正了强制矢量破坏包含在时间测量中的代码。

Answer 4

将分配更改为例如。 arr[i*size+j] = i*j，或其他一些非常量表达式。我认为编译器优化了整个循环，因为从未使用过分配的值，或者用一些预先计算的值替换数组，所以甚至没有执行循环并且你得到 0 毫秒。

将 1 更改为 i*j，i 获得相同的向量和数组计时，除非将 -O1 标志传递给 gcc，然后在这两种情况下我都得到 0 毫秒。

因此，首先，请仔细检查您的循环是否实际执行。

Answer 5

您可能正在使用 VC++，在这种情况下，默认情况下标准库组件会在运行时执行许多检查（例如索引是否在范围内）。可以通过将一些宏定义为 0 来关闭这些检查（我认为是 _SECURE_SCL）。

另一件事是我什至无法按原样运行您的代码：自动数组对于堆栈来说太大了。当我将其设为全局时，使用 MingW 3.5 时，向量的时间为 627 毫秒，数组的时间为 26875 毫秒（！！），这表明这种大小的数组确实存在很大问题。

对于这个特定的操作（填充值 1），您可以使用向量的构造函数：

std::vector<int> v(size * size, 1);

以及数组的填充算法：

std::fill(arr, arr + size * size, 1);

Answer 6

两件事。一， operator[] 对于向量来说要慢得多。第二，当您一次添加一个元素时，大多数实现中的向量有时会表现得很奇怪。我的意思不仅仅是它分配了更多的内存，而是它有时会做一些真正奇怪的事情。

第一个是主要问题。对于仅仅一百万字节，即使重新分配内存十几次也不应该花费很长时间（它不会在每个添加的元素上都这样做）。

在我的实验中，预分配并没有太大改变它的缓慢性。当内容是实际对象时，如果你尝试做一些简单的事情，比如对它进行排序，它基本上会停止。

结论，不要将 stl 或 mfc 向量用于任何大型或计算量大的东西。它们的实现很差/很慢，会导致大量内存碎片。

Answer 7

当您声明数组时，它位于堆栈（或静态内存区域）中，它非常快，但无法增加其大小。

当你声明向量时，它会分配动态内存，它不是那么快，但在内存分配上更灵活，所以你可以改变大小而不是将它的维度设置为最大大小。

Answer 8

在分析代码时，请确保您正在比较相似的内容。

vector<int> v(size*size); 

初始化向量中的每个元素，

int arr[size*size]; 

没有。试试

int arr[size * size];
memset( arr, 0, size * size );

然后再次测量...