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

（我已经阅读了lambda派生的隐式函子在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类型的擦除，这似乎也有问题。

如果您将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函数本地创建对象，然后将其完整移动（包括[ x]的值）到返回值中，然后本地实例将超出范围并被正常销毁。但是，从函数返回的对象将一直保持有效，直到std::function保存它的对象为止。显然，要多长时间取决于调用上下文。

似乎您std::function比lambda更困惑。

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; } );

这是：

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

等效于：（或也可以考虑）

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

因此，您的对象正在返回看起来像这样的对象。其中有一个定义良好的副本构造函数。因此，可以将其正确复制到函数中似乎非常合理。

在您发布的代码中：

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 ++编译器可能会为定义的lambda生成以下类类型[x](int y) { return x + y; }：

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中函数循环的示例。