C++ lambda 表达式的生命周期是多少?
(我已经阅读了 什么是生命周期C++ 中的 lambda 派生隐式函子? 已经,它没有回答这个问题.)
(I have read What is the lifetime of lambda-derived implicit functors in C++? already and it does not answer this question.)
我了解 C++ lambda 语法只是用于创建具有调用运算符和某些状态的匿名类的实例的糖,并且我了解该状态的生命周期要求(取决于您是否通过引用的值捕获.)但是 lambda 对象本身的生命周期是多少?在以下示例中,返回的 std::function
实例有用吗?
I understand that C++ lambda syntax is just sugar for making an instance of an anonymous class with a call operator and some state, and I understand the lifetime requirements of that state (decided by whether you capture by value of by reference.) But what is the lifetime of the lambda object itself? In the following example, is the std::function
instance returned going to be useful?
std::function<int(int)> meta_add(int x) {
auto add = [x](int y) { return x + y; };
return add;
}
如果是,它是如何工作的?这对我来说似乎有点太神奇了 - 我只能想象它通过 std::function
复制我的整个实例来工作,这取决于我捕获的内容可能非常繁重 - 过去我已经std::function
主要用于裸函数指针,复制它们很快.鉴于 std::function
的类型擦除,它似乎也有问题.
If it is, how does it work? This seems a bit too much magic to me - I can only imagine it working by std::function
copying my whole instance, which could be very heavy depending on what I captured - in the past I've used std::function
primarily with bare function pointers, and copying those is quick. It also seems problematic in light of std::function
's type erasure.
推荐答案
生命周期正是如果你用一个手卷函子替换你的 lambda 的生命周期:
The lifetime is exactly what it would be if you replaced your lambda with a hand-rolled functor:
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 itsentirty,包括 x
的值] 到返回值,然后本地实例将超出范围并正常销毁.但是,只要持有它的 std::function
对象有效,从函数返回的对象就会一直有效.这显然取决于调用上下文.
The object will be created, local to the meta_add
function, then moved [in its entirty, including the value of x
] into the return value, then the local instance will go out of scope and be destroyed as normal. But the object returned from the function will remain valid for as long as the std::function
object that holds it does. How long that is obviously depends on the calling context.
相关文章