C++ lambda 表达式的生命周期是多少？

Question

（我已经阅读了What is the lifetime of lambda-derived implicit functors in C++?，它没有回答这个问题。）

我了解 C++ lambda 语法只是用于创建具有调用运算符和某些状态的匿名类的实例的糖，并且我了解该状态的生命周期要求（取决于您是否通过引用的值捕获。）但是 lambda 对象本身的生命周期是多少？在以下示例中，返回的 std::function 实例是否有用？

std::function<int(int)> meta_add(int x) {
    auto add = [x](int y) { return x + y; };
    return add;
}

如果是，它是如何工作的？这对我来说似乎有点太神奇了——我只能想象它通过 std::function 复制我的整个实例来工作，根据我捕获的内容，这可能非常重——过去我主要使用了 std::function 与裸函数指针，复制它们很快。鉴于std::function 的类型擦除，这似乎也有问题。

Answer 1

生命周期与将 lambda 替换为手动仿函数的情况完全相同：

struct lambda {
   lambda(int x) : x(x) { }
   int operator ()(int y) { return x + y; }

private:
   int x;
};

std::function<int(int)> meta_add(int x) {
   lambda add(x);
   return add;
}

对象将被创建，在 meta_add 函数的本地，然后将 [in its entirty, including the value of x] 移动到返回值中，然后本地实例将超出范围并被销毁为普通的。但只要持有它的std::function 对象，从函数返回的对象将保持有效。这显然取决于调用上下文。

Answer 2

您似乎对 std::function 比对 lambdas 更困惑。

std::function 使用一种称为类型擦除的技术。快速浏览一下。

class Base
{
  virtual ~Base() {}
  virtual int call( float ) =0;
};

template< typename T>
class Eraser : public Base
{
public:
   Eraser( T t ) : m_t(t) { }
   virtual int call( float f ) override { return m_t(f); }
private:
   T m_t;
};

class Erased
{
public:
   template<typename T>
   Erased( T t ) : m_erased( new Eraser<T>(t) ) { }

   int do_call( float f )
   {
      return m_erased->call( f );
   }
private:
   Base* m_erased;
};

为什么要擦除类型？我们想要的类型不就是int (*)(float)吗？

类型擦除允许Erased 现在可以存储任何可调用的值，例如int(float)。

int boring( float f);
short interesting( double d );
struct Powerful
{
   int operator() ( float );
};

Erased e_boring( &boring );
Erased e_interesting( &interesting );
Erased e_powerful( Powerful() );
Erased e_useful( []( float f ) { return 42; } );

Answer 3

这是：

[x](int y) { return x + y; };

相当于：（或者也可以考虑）

struct MyLambda
{
    MyLambda(int x): x(x) {}
    int operator()(int y) const { return x + y; }
private:
    int x;
};

所以你的对象正在返回一个看起来像这样的对象。它有一个定义明确的复制构造函数。所以它可以正确地从函数中复制出来，这似乎是非常合理的。

Answer 4

在您发布的代码中：

std::function<int(int)> meta_add(int x) {
    auto add = [x](int y) { return x + y; };
    return add;
}

函数返回的 std::function<int(int)> 对象实际上保存了一个已移动的 lambda 函数对象实例，该实例已分配给局部变量 add。

当您定义捕获按值或按引用的 C++11 lambda 时，C++ 编译器会自动生成唯一的函数类型，该类型的实例是在调用 lambda 或将其分配给变量时构造的。为了说明，您的 C++ 编译器可能会为 [x](int y) { return x + y; } 定义的 lambda 生成以下类类型：

class __lambda_373s27a
{
    int x;

public:
    __lambda_373s27a(int x_)
        : x(x_)
    {
    }

    int operator()(int y) const {
        return x + y;
    }
};

那么，meta_add 函数本质上等价于：

std::function<int(int)> meta_add(int x) {
    __lambda_373s27a add = __lambda_373s27a(x);
    return add;
}

编辑：顺便说一句，我不确定你是否知道，但这是 C++11 中函数 currying 的示例。