std :: functions和lambda函数传递

Question

我有一个类，它将std::function作为参数，我分配了一个lambda函数。 它在构造函数中工作，但之后停止工作。 调试器在运行第一行后表示f为“空”。 为什么？

#include <iostream>
#include <string>
#include <functional>

typedef std::function<void(std::string)> const& fn;

class TestClass
{
public:
    TestClass(fn _f) : f(_f) { F(); }
    void F() { f("hello"); };

private:
    fn f;
};


int main()
{
    TestClass t([](std::string str) {std::cout << str << std::endl; });

    t.F();

    return 0;
}

调用tF()会导致错误。 为什么？

我可以通过将其更改为以下内容来解决此问题：

int main()
{
    fn __f = [](std::string str) {std::cout << str << std::endl; };
    TestClass t(__f);

    t.F();

    return 0;
}

但是，当我将fn更改为auto时，这不起作用！

int main()
{
    auto __f = [](std::string str) {std::cout << str << std::endl; };
    TestClass t(__f);

    t.F();

    return 0;
}

为什么会发生这种情况的原因是什么？

Answer 1

注意（1） fn定义为引用 （对const）; （2）lambda和std::function的类型不一样; （3）您不能直接绑定对不同类型的对象的引用。

对于第一种情况，

TestClass t([](std::string str) {std::cout << str << std::endl; });
t.F();

创建一个临时lambda，然后转换为std::function ，这也是一个临时的。 临时std::function绑定到构造std::function的参数_f并绑定到成员f 。 在此声明之后，临时将被销毁，然后当tF();时f变为悬空tF(); 它失败。

对于第二种情况，

fn __f = [](std::string str) {std::cout << str << std::endl; };
TestClass t(__f);
t.F();

创建临时lambda然后绑定到引用（到const）。 然后它的生命周期延长到引用__f的生命周期，所以代码很好。

对于第三种情况，

auto __f = [](std::string str) {std::cout << str << std::endl; };
TestClass t(__f);
t.F();

创建lambda然后转换为std::function ，这是一个临时的。 临时std::function绑定到构造std::function的参数_f并绑定到成员f 。 在此声明之后，临时将被销毁，然后当tF();时f变为悬空tF(); 它失败。

---

^{（1）你可以将fn声明为非引用，如typedef std::function<void(std::string)> fn; ，然后将复制std::function并且每个案例都能正常工作。
（2）不要使用以双下划线开头的名称，它们是在C ++中保留的。}

Answer 2

typedef std::function<void(std::string)> const& fn;

这不是std::function ，它是对std::function的引用。

TestClass(fn _f) : f(_f) { F(); }
fn f;

在这里，你将一个const&一个std::function绑定到另一个const&一个std::function 。 构造函数体中的F()起作用，因为引用至少与构造函数一样有效。

TestClass t([](std::string str) {std::cout << str << std::endl; });

这将创建一个从lambda创建的std::function临时文件。 这个临时持续时间与当前行一样长（直到; ）。

然后丢弃临时std::function 。

由于TestClass通过const&获取std::function ，因此它不会延长临时生命周期。

所以在行之后，对std::function const&任何调用都是未定义的行为，你在稍后调用.F()会看到这种行为。

fn __f = [](std::string str) {std::cout << str << std::endl; };

这确实参考了寿命延长。 从lambda创建的临时std::function的生命周期延长到__f变量的生命周期。

顺便说一句，这一行也会使你的程序形成错误，不需要诊断，因为它有一个包含双下划线的变量。 这些标识符保留用于编译器的实现，您可能无法创建它们。

TestClass t(__f);

然后我们传递这个引用（指的是生命周期扩展临时），一切正常。

auto __f = [](std::string str) {std::cout << str << std::endl; };

这会创建一个变量__f （参见上面的错误名称），它是一个lambda。

lambda不是std::function 。 可以隐式地从lambda创建std::function 。

TestClass t(__f);

这将从lambda创建一个临时的std::function ，将其传递给TestClass构造函数，然后销毁临时的。

在此行之后，对.F()的调用最终会在悬空引用之后，并且会导致未定义的行为。

你的核心问题可能是你认为lambda是一个std::function 。 它不是。 std::function可以存储lambda。

你的第二个问题是将某个东西定义为const& ，这几乎总是一个非常愚蠢的想法。 引用的行为与基本方式的值不同。

您的第三个问题是变量名称中的双重修正。 （或以_后跟大写字母开头的标识符）。

如果你想知道std::function如何工作以及它是什么，那么在这个主题上有很多好的SO帖子，有各种级别的技术细节。