Lambda（通过引用与按值将 lambda 传递给函数）

Question

当使用 lambda 创建 std::function 时，std::function 在内部制作 lambda 对象的副本。因此，我们调用 fn() 实际上是在我们的 lambda 副本上执行的，而不是实际的 拉姆达。

根据上面的陈述，在 std::function 总是复制 lambda 对象时，在下面的代码中通过 'reference using &' 或通过 'value' 传递 lambda 有什么意义？

换句话说，在下面的代码中，当'invoke'函数的参数通过引用或值传递时，lambda的哪一部分将不会被修改/影响？

#include <iostream>
#include <functional>
 
void invoke(const std::function<void(void)>& fn) // # PASS LAMBDA BY REFERENCE*********************
 
{
    fn();
}
 
int main()
{
    int i{ 0 };
 
    // Increments and prints its local copy of @i.
    auto count{ [i]() mutable {
      std::cout << ++i << '\n';
    } };
 
    invoke(count);
    invoke(count);
    invoke(count);
 
    return 0;
}

#include <iostream>
#include <functional>
 
void invoke(const std::function<void(void)> fn) // # PASS LAMBDA BY VALUE*********************
{
    fn();
}
 
int main()
{
    int i{ 0 };
 
    // Increments and prints its local copy of @i.
    auto count{ [i]() mutable {
      std::cout << ++i << '\n';
    } };
 
    invoke(count);
    invoke(count);
    invoke(count);
 
    return 0;

Answer 1

您混合了两件事 - 通过引用传递和强制转换。

通过引用传递

这大致是 lambda 的实现方式：

struct Lambda{
    //Capture by value
    Lambda(int i):_i(i){}

    void operator()() const{
        std::cout << ++_i << '\n';
    }
    mutable int _i;
};
//BTW const is somewhat redundant
void invoke1(const Lambda fn) // # PASS LAMBDA BY VALUE
{
    fn();
}
//Const is important, but not yet.
void invoke2(const Lambda& fn) // # PASS LAMBDA BY REFERENCE
{
    fn();
}
 
int main()
{
    int i{ 0 };
 
    // Increments and prints its local copy of @i.
    Lambda count{i};
 
    invoke1(count);//1
    invoke1(count);//1
    invoke1(count);//1

    invoke2(count);//1
    invoke2(count);//2
    invoke2(count);//3
 
    return 0;
}

代码产生您可能想要的输出。 请注意，mutable 的用法是完全不正确的，但我是这样做的，因此代码可以编译。请参阅 link 了解 std::function 是如何做到这一点的。

铸造

正如@Jarod42 所写，lambda 不是std::function，但它可以通过std::function 的构造函数隐式转换为1。 这根本不是std::function 的实现方式，为了允许捕获任何可调用对象，涉及到更多的魔法。但它说明了这一点。

#include <iostream>
#include <functional>
 
struct Lambda{
    //Capture by value
    Lambda(int i):_i(i){}

    void operator()() const{
        std::cout << ++_i << '\n';
    }
    mutable int _i;
};

struct Function{
    //Makes a copy.
    Function(Lambda lambda):_lambda(std::move(lambda)){}

    void operator()() const{
        _lambda();
    }

    Lambda _lambda;
};


void invoke1(const Function fn) // # PASS FUNCTION BY VALUE
{
    fn();
}
//Const is very important.
void invoke2(const Function& fn) // # PASS FUNCTION BY REFERENCE
{
    fn();
}
 
int main()
{
    int i{ 0 };
 
    // Increments and prints its local copy of @i.
    Lambda count{i};
 
    invoke1(count);//1
    invoke1(count);//1
    invoke1(count);//1

    invoke2(count);//1
    invoke2(count);//1
    invoke2(count);//1
    
 
    return 0;
}

所有invoke2 调用仍会打印1，因为每次调用都会创建一个新的Function 对象，该对象会创建自己的count lambda 对象的本地副本。当然，invoke1 调用也发生了同样的情况，但这并没有什么区别，因为无论哪种方式都可以复制。

注意invoke2(const Function&) 中的 const 非常重要，没有它调用会导致编译错误。这是因为const Function& 允许参数绑定到 L 值和 R 值（~temporaries）。