我必须在lambda内进行异步调用,并且一旦异步调用终止,我就必须调用lambda本身。
我尝试用代码解释我的问题:
typedef function<void(int id)> Callback;
AsyncWork1(Callback call, int id, string)
{
//...
call(id);
}
AsyncWork2(Callback call, int id, double, string)
{
//...
call(id);
}
void AsyncWorks(Callback final_callback, int id)
{
Callback lambda = [&lambda, final_callback, id](int next_work) -> void
{
if(next_work == 1)
{
//...
AsyncWork1(lambda, 2, "bla bla");
}
else if(next_work == 2)
{
//...
//the lambda variable no longer exists
AsyncWork2(lambda, 3, 0.0, "bla bla");
}
else if(next_work == 3)
{
//...
final_callback(id);
}
};
lambda(1);
}
int main()
{
AsyncWorks(...);
AsyncWorks(...);
AsyncWorks(...);
AsyncWorks(...);
return 0;
}
问题是,当代码从“AsyncWorks(...)”函数退出时,局部变量“lambda”不再存在。
我已经阅读了几个有关lambda递归的主题,但是还没有找到任何解决方案。
我怎么解决这个问题?
最佳答案
基本问题是C++不会向其自身公开Lambda的this
指针。
碰巧的是,在定义某些东西的过程中,有许多种语言无法引用自身。使用称为“Y Combinator”的技术将其固定在功能语言中。
C++中一个简单的y组合器如下所示:
template<class F>
struct y_combinator_t {
F f;
template<class...Args>
auto operator()(Args&&...args)
-> std::result_of_t< F&( y_combinator_t<F>&, Args&&... ) >
{
return f( *this, std::forward<Args>(args)... );
}
};
template<class F>
y_combinator_t<std::decay_t<F>> y_combinate( F&& f ) {
return {std::forward<F>(f)};
}
如果我们应该使用
f( *this
或f( f
,我有两种想法,有时我也可以这样做。使用:
void AsyncWorks(Callback final_callback, int id)
{
Callback lambda = y_combinate(
[final_callback, id]
(auto& self, int next_work)
-> void
{
if(next_work == 1) {
//...
AsyncWork1(self, 2, "bla bla");
} else if(next_work == 2) {
//...
//the lambda variable no longer exists
AsyncWork2(self, 3, 0.0, "bla bla");
} else if(next_work == 3) {
//...
final_callback(id);
}
}
);
lambda(1);
}
基本上,我在lambda函数主体中添加了一个隐式
self
参数。 operator()
的调用者看不到此参数。Y组合器基于this post by myself进行了修改。
关于c++ - Lambda如何捕获自己以进行异步调用?,我们在Stack Overflow上找到一个类似的问题:https://stackoverflow.com/questions/56363323/