c++ - 通过 lambda 函数中的引用/值捕获成本？

Question

考虑以下代码:

#include <iostream>
#include <algorithm>
#include <numeric>

int main()
{
    const unsigned int size = 1000;
    std::vector<int> v(size);
    unsigned int cst = size/2;
    std::iota(v.begin(), v.end(), 0);
    std::random_shuffle(v.begin(), v.end());
    std::cout<<std::find_if(v.begin(), v.end(), [&cst](const int& i){return i == cst;})-v.begin()<<std::endl;
    std::cout<<std::find_if(v.begin(), v.end(), [=](const int& i){return i == cst;})-v.begin()<<std::endl;
    return 0;
}

此代码用值填充 vector ，对其进行打乱，然后搜索指定值的索引(这只是说明我的问题的示例)。此值 cst 可以通过引用或 lambda 函数中的值来捕获。

我的问题:这两个版本之间的性能是否存在差异，或者编译器会以相同的方式对其进行优化？

按值传递常量基本类型和按引用传递常量类(就像在普通函数中一样)是一个很好的规则吗？

Answer 1

在实践中，小型类型没有性能差异。

使用 clang -O3 在这两种情况下我得到相同的代码。没有优化 clang 生成不同的代码，复制版本恰好是一个更小的指令。

$ clang ref.cpp -O3 -std=c++11 -S -o ref.s
$ clang cpy.cpp -O3 -std=c++11 -S -o cpy.s
$ diff ref.s cpy.s

有一个与 const 相关的小差异。

复制捕获给你一个 const unsigned 值。这将不编译:

unsigned cst = 123;
[=](const int& i){ return i == ++cst; }

非常量变量的引用捕获导致非常量 unsigned& 引用。这会修改原始值作为副作用:

unsigned cst = 123;
[&](const int& i){ return i == ++cst; }

作为一个好的规则，应该避免复制大对象。如果小对象在 lambda 范围内应该是常量，但在当前范围内不是常量，复制捕获是一个不错的选择。如果 lambda 的生命周期超过本地对象的生命周期，则复制捕获是唯一的选择。