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

10-08 22:47
查看更多