c++ - lambda 如何捕获自身以进行异步调用？

Question

我必须在 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 递归的线程，但我还没有找到任何解决方案。

我该如何解决这个问题？

Answer 1

基本问题是 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有修改。