С++ 为什么数组比向量至少快 32%？ [关闭]

Question

例如我们有一系列数字 [0, 1, 2, ... N]
我们需要以相反的顺序排列它们 [N, ... 2, 1, 0]
使用数组还是向量更好？
如果我们使用向量，那么使用“交换”还是使用缓冲区？

使用“交换”：

for (int i = 0; i < NUMBS / 2; i++)
        std::swap(vec[i], vec[(NUMBS - 1) - i]);

使用缓冲区：

int buf;
for (int i = 0; i < NUMBS / 2; i++) {
    buf = vec[i];
    vec[i] = vec[(NUMBS - 1) - i];
    vec[(NUMBS - 1) - i] = buf;
}

我写了一个小代码来证明在这个任务中数组比向量更快：

#include <iostream>
#include <vector>
#include <chrono>
#include <algorithm>
#include <cmath>

#define NUMBS 20000000

std::vector<int> vec;
int arr[NUMBS];

float timeVswap;
float timeVbuf;
float timeAbuf;

class Timer {
private:
    using clock_t = std::chrono::high_resolution_clock;
    using second_t = std::chrono::duration<double, std::ratio<1> >;

    std::chrono::time_point<clock_t> m_beg;

public:
    Timer() : m_beg(clock_t::now()) {
    }

    void reset() {
        m_beg = clock_t::now();
    }

    double elapsed() const {
        return std::chrono::duration_cast<second_t>(clock_t::now() - m_beg).count();
    }
};

void Vswap() {
    Timer t;
    t.reset();

    for (int i = 0; i < NUMBS / 2; i++)
        std::swap(vec[i], vec[(NUMBS - 1) - i]);

    timeVswap = t.elapsed();
}

void Vbuf() {
    Timer t;
    t.reset();

    int buf;
    for (int i = 0; i < NUMBS / 2; i++) {
        buf = vec[i];
        vec[i] = vec[(NUMBS - 1) - i];
        vec[(NUMBS - 1) - i] = buf;
    }

    timeVbuf = t.elapsed();
}

void Abuf() {
    Timer t;
    t.reset();

    int buf;
    for (int i = 0; i < NUMBS / 2; i++) {
        buf = arr[i];
        arr[i] = arr[(NUMBS - 1) - i];
        arr[(NUMBS - 1) - i] = buf;
    }

    timeAbuf = t.elapsed();
}

int main() {
    Timer t;

    for (int i = 0; i < NUMBS; i++) {
        vec.push_back(i);
        arr[i] = i;
    }

    Vswap();
    Vbuf();
    Abuf();

    std::cout << "Time for vector (swap):   " << timeVswap << " sec.\n";
    std::cout << "Time for vector (buf):    " << timeVbuf << " sec.\n";
    std::cout << "------------------------------------\n";
    std::cout << "Time for array (buf):     " << timeAbuf << " sec.\n";
    std::cout << "\n";
    std::cout << "array is faster: " << floorf(100 - timeAbuf / timeVbuf * 100) << " %\n";

    return 0;
}

我得到了这样的结果：

Answer 1

С++ 为什么数组至少比向量快 32%？

不是。

您没有打开编译器优化，因此您的结果不能代表std::vector comares 在实际应用程序中的排列方式。

通过-O3 使用 gcc 开启优化后，我得到了输出：

array is faster: -2 %

在另一次运行中：

Time for vector (swap):   0.0100716 sec.
Time for vector (buf):    0.00857671 sec.
------------------------------------
Time for array (buf):     0.00842298 sec.

array is faster: 1 %

请注意，绝对时间很小。这暗示编译器意识到当它实际上没有对向量和数组进行任何交换或反转时，它没有可观察到的效果。您必须使用计算结果来确保编译器不会优化您实际想要测量的内容。