就百分比而言，这两种方法之间的平均性能差异有多大？

Question

在尝试了解标准库的实现时，我有一个问题。

给定

std::vector<int> myVec = { ... }; // some vector of ints

以下哪项平均速度更快，速度快多少，为什么？

(1)

for (int i(0), j(myVec.size()); i < j; ++i) std::cout << myVec[i];

或

(2)

for (std::vector<int>::iterator i(myVec.begin()), j(myVec.end()); i != j; ++i) std::cout << *it;

Answer 1

让我们看看...

第一个循环：在std::vector对象上调用size成员函数N次operator[]和std::cout上N次operator<<。

第二个循环：在std::vector 对象上调用begin 和end 成员函数，在std::cout 上取消引用vector<int>::iterator 和N 次operator<<。

以下操作：size、operator[]、begin、end 和取消引用 vector<int>::iterator 具有恒定的复杂性。换句话说，没什么。 operator[] 可能会导致向基地址添加一些数字，并且向量迭代器很可能是原始指针。很明显，在标准输出上打印内容是这里的主导因素，这在两种情况下都是相同的。一般来说，没有理由相信其中一个会比另一个快。

只是为了好玩，我在笔记本电脑上尝试过，但我认为没有什么值得讨论的区别。

gdb 反汇编：gcc 4.8 (g++ -g -std=c++11 -O2 file.cc)：

    Dump of assembler code for function main():
    5       {
       0x0000000000400880 <+0>:     push   %r12
       0x000000000040088d <+13>:    push   %rbp
       0x000000000040088e <+14>:    push   %rbx

    6         std::vector<int> myVec = { 1, 2, 3, 5, 6, 7 }; // some vector of ints
    7
    8         for (int i(0), j(myVec.size()); i < j; ++i) std::cout << myVec[i];
       0x0000000000400887 <+7>:     mov    $0x6,%r12d
       0x000000000040088f <+15>:    xor    %ebx,%ebx
       0x00000000004008c0 <+64>:    mov    0x0(%rbp,%rbx,4),%esi
       0x00000000004008c4 <+68>:    mov    $0x601080,%edi
       0x00000000004008c9 <+73>:    callq  0x4007d0 <_ZNSolsEi@plt>
       0x00000000004008ce <+78>:    add    $0x1,%rbx
       0x00000000004008d2 <+82>:    cmp    %ebx,%r12d
       0x00000000004008d5 <+85>:    jg     0x4008c0 <main()+64>

    9
    10        std::cout << std::endl;
    11
    12        for (std::vector<int>::iterator it(myVec.begin()), j(myVec.end()); it != j; ++it) std::cout << *it;
       0x00000000004008f0 <+112>:   mov    (%rbx),%esi
       0x00000000004008f2 <+114>:   mov    $0x601080,%edi
       0x00000000004008f7 <+119>:   callq  0x4007d0 <_ZNSolsEi@plt>
       0x00000000004008fc <+124>:   add    $0x4,%rbx
       0x0000000000400900 <+128>:   cmp    %r12,%rbx
       0x0000000000400903 <+131>:   jne    0x4008f0 <main()+112>

    13
    14        std::cout << std::endl;
    15      }
       0x000000000040091c <+156>:   pop    %rbx
       0x000000000040091d <+157>:   pop    %rbp
       0x000000000040091e <+158>:   xor    %eax,%eax
       0x0000000000400920 <+160>:   pop    %r12
       0x0000000000400922 <+162>:   retq

Answer 2

第二种情况更快。

当你递增迭代器时，你只是递增指针。

对具有索引的元素的访问包括将索引乘以类型的大小，以计算指针。

Answer 3

这个问题涉及的依赖项和未知数太多。

在第一种情况下，您正在调用一个函数来访问一个元素。可以优化该函数以消除函数调用的开销并归结为乘法和加法运算。

第二种情况涉及对访问内存的指针的取消引用。

这里的问题之一是处理器的功能。许多现代处理器能够通过取消引用（使用零索引）或通过使用单个指令从指针索引来从内存中获取值。

另一个影响是向量是否可以放入处理器的高速缓存行（如果它有数据高速缓存）。缓存线之外的任何数据都需要额外的处理逻辑。

如果一种方法比另一种方法快，则可以忽略不计，除非您执行 1E+10 次迭代。差异通常以纳秒为单位。您的程序将浪费更多时间被操作系统换出、调用函数或执行 I/O。一个例子：差异是10ns。您的程序等待 0.5 秒让用户输入一个值。每次迭代 10ns 的增益被浪费在等待用户输入上。

通常，此类微优化仅对高性能应用程序或必须满足关键期限的应用程序至关重要。例如，如果嵌入式系统必须每毫秒读取一次传感器，那么读取传感器所花费的时间越少，系统其余部分执行的时间就越多。

编辑 1：
像这样的微优化还取决于数据的来源。内存离处理器内核越远，读取越慢。例如，从同一块硅片上的内存中获取数据会比从位于子板上的闪存设备访问更快。