我必须在 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/