c++ - 基于范围的for循环，哪个更快？

如果我们对字符串使用基于范围的for循环，使用会不会有好处

for (auto const & c : s)

过度

for (auto c : s)

// c => char
// s => std::string

我之所以这样问，是因为内存中只有一个字节的chars复制起来并不那么昂贵，这让我昨晚感到好奇。

我做了一些基准测试！

结果：

// In Milliseconds

// 1000
// BY COPY: 7
// BY _REF: 5

// 10000
// BY COPY: 51
// BY _REF: 50

// 100000
// BY COPY: 503
// BY _REF: 501

// 1000000
// BY COPY: 5047
// BY _REF: 5101

// 10000000
// BY COPY: 52058
// BY _REF: 56160

码：

#include <chrono>
#include <iostream>
#include <string>

using std::cout;
using std::endl;

bool by_copy(std::string const & s);
bool by_const_ref(std::string const & s);

int main() {
    std::string const test {"0000000001"};

    auto start {std::chrono::steady_clock::now()};
    for (unsigned long long i {}; i < 10000000; ++i) {
        bool b {by_copy(test)};
        if (b) {}
    }
    auto end {std::chrono::steady_clock::now()};
    auto duration {std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()};
    cout << "BY COPY: " << duration << '\n';

    start = std::chrono::steady_clock::now();
    for (unsigned long long i {}; i < 10000000; ++i) {
        bool b {by_const_ref(test)};
        if (b) {}
    }
    end = std::chrono::steady_clock::now();
    duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    cout << "BY _REF: " << duration << '\n';

    return 0;
}

bool by_copy(std::string const & s) {
    for (auto c : s) {
        if (c == '1') {
            return true;
        }
    }
    return false;
}

bool by_const_ref(std::string const & s) {
    for (auto const & c : s) {
        if (c == '1') {
            return true;
        }
    }
    return false;
}

更新

出于好奇，我也对索引进行了基准测试，它比基于范围的for循环要快得多，为什么？

结果

    // 1000
    // BY COPY: 7
    // BY _REF: 5
    // BYINDEX: 4

    // 10000
    // BY COPY: 59
    // BY _REF: 58
    // BYINDEX: 37

    // 100000
    // BY COPY: 526
    // BY _REF: 495
    // BYINDEX: 326

    // 1000000
    // BY COPY: 5751
    // BY _REF: 5038
    // BYINDEX: 3308

    // 10000000
    // BY COPY: 62202
    // BY _REF: 63002
    // BYINDEX: 38744

by_index函数：

bool by_index(std::string const & s) {
    for (size_t i {}; i < s.size(); ++i) {
        if (s[i] == '1') {
            return true;
        }
    }
    return false;
}

最佳答案

为澄清起见，我解释您的问题是为了使您遍历字符串的字符-而不是遍历字符串容器。

不，没有优势。实际上，由于隐含的间接性，理论上存在参考速度变慢的可能性。但是，两种变体都可能编译为完全相同的机器代码，因为体面的优化程序将能够避免这种间接调用。

关于c++ - 基于范围的for循环，哪个更快？，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/41443557/