Question

我看到了这个用户post yesterday。我认为这是输出矢量的一种很酷的方式。所以我输入了一个示例，并问自己这与for each循环相比如何？

template <typename T>
void printVectorO(std::vector<T> &v)
{
    std::cout << "Ostream_iterator contents: " << std::endl;
    auto start = std::chrono::high_resolution_clock::now();
    std::ostream_iterator<T> ost(std::cout, " ");
    std::copy(begin(v), end(v), ost);
    std::cout << std::endl;

    auto end = std::chrono::high_resolution_clock::now();
    auto time = end - start;
    auto nano = std::chrono::duration_cast<std::chrono::nanoseconds>(time);
    std::cout << "Ostream_iterator computation took: " << nano.count() << " nano seconds"<< std::endl;
    std::cout << std::endl;
}

template <typename T>
void printVectorC(std::vector<T> &v)
{
    std::cout << "For Each Loop contents: " << std::endl;
    auto start = std::chrono::high_resolution_clock::now();
    for (auto && e : v) std::cout << e << " ";
    std::cout << std::endl;

    auto end = std::chrono::high_resolution_clock::now();
    auto time = end - start;
    auto nano = std::chrono::duration_cast<std::chrono::nanoseconds>(time);
    std::cout << "For Each Loop took: " << nano.count() << " nano seconds" << std::endl;
    std::cout << std::endl;
}

我使用了3个向量来测试它：

std::vector<double> doubles = { 3.15, 2.17, 2.555, 2.014 };
std::vector<std::string> strings = { "Hi", "how", "are", "you" };
std::vector<int> ints = { 3, 2 , 2 , 2 };

我得到了各种结果。当我输出双打时，for each循环总是胜过ostream_iterator（ex 41856 vs 11207和55198 vs 10308 nanose）。有时，字符串ostream_iterator击败for each循环，而for each循环和ostream_iterator几乎与整数保持一致。

这是为什么？ ostream_iterator的幕后发生了什么？在效率和速度方面，我何时会在ostream_iterator循环上使用for each？

Answer 1

提防微基准测试。

关于此代码，我有几点一般评论：

将只读变量作为const引用而不是常规引用传递。不过，这不会影响性能
不要使用std :: endl，因为它会调用flush（），这最终会占用您大部分的运行时间（在这种微型基准测试中）。例如，使用std :: endl打印双精度花了37010 ns，而使用'\ n'
单项测量不准确。为了消除任何测量噪声，您必须循环运行多次。这仍然是不完善的，因为最好的办法是可以交替运行测试（产生随机事件，这可能会减慢代码的速度，以相同的方式影响两个实现）
最好将其重定向到文件，否则终端速度将主导结果。

这是更正的基准：

constexpr unsigned ITERATIONS = 1000000;
template <typename T>
void printVectorO(const std::vector<T> &v)
{
    std::cout << "Ostream_iterator contents\n";
    auto start = std::chrono::high_resolution_clock::now();
    for (unsigned i=0 ; i < ITERATIONS; ++i) {
        std::ostream_iterator<T> ost(std::cout, " ");
        std::copy(begin(v), end(v), ost);
        std::cout << '\n';
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto time = end - start;
    auto nano = std::chrono::duration_cast<std::chrono::nanoseconds>(time);
    std::cout << "Ostream_iterator computation took: "
              << nano.count() / ITERATIONS << " nano seconds\n\n";
}

template <typename T>
void printVectorC(const std::vector<T> &v)
{
    std::cout << "For Each Loop contents\n";
    auto start = std::chrono::high_resolution_clock::now();
    for (unsigned i=0 ; i < ITERATIONS ; ++i) {
        for (auto && e : v) std::cout << e << " ";
        std::cout << '\n';
    }

    auto end = std::chrono::high_resolution_clock::now();
    auto time = end - start;
    auto nano = std::chrono::duration_cast<std::chrono::nanoseconds>(time);
    std::cout << "For Each Loop took: "
              << nano.count() / ITERATIONS << " nano seconds\n\n";
}

并通过以下方式调用它：

template <class Container>
void test(const Container & ctr)
{
    printVectorC2(ctr);
    printVectorO2(ctr);
}


int main()
{
    std::vector<double> doubles = { 3.15, 2.17, 2.555, 2.014 };
    test(doubles);
    std::vector<std::string> strings = { "Hi", "how", "are", "you" };
    test(strings);
    std::vector<int> ints = { 3, 2 , 2 , 2 };
    test(ints);
}

现在，在为nano进行grep之后，我们有了：

For Each Loop took: 2045 nano seconds
Ostream_iterator computation took: 2033 nano seconds
For Each Loop took: 487 nano seconds
Ostream_iterator computation took: 485 nano seconds
For Each Loop took: 503 nano seconds
Ostream_iterator computation took: 499 nano seconds

几乎没有任何区别。实际上，通过这种特定的运行，似乎认为ostream版本更快。但是再次运行会产生稍微不同的结果。

ostream_iterator vs每个循环效率

1 个答案: