处理嵌套回调

Question

我遇到了需要处理嵌套回调的情况。请参阅Thing::process 函数。第二个g_thing.onAfterWalk() 回调永远不会被调用，因为父级回调一旦完成就会销毁它。

Thing g_thing;

void Thing::walk(int32_t x, int32_t y) {
    if (SYSTIME() > m_walkEndTime) {
        // Still walking
        return;
    }

    auto obj = g_thing.localObject();
    auto walkDuration = obj->getWalkDurationTo(x, y);
    [..]
    m_walkEndTime = SYSTIME() + walkDuration;

    [..]

    // Walk finished. Run callback
    if (m_afterWalk) {
        m_afterWalk();
        m_afterWalk = nullptr;
    }
}

void Thing::onAfterWalk(std::function<void(void)>& callback) {
    m_afterWalk = callback;
}

void Thing::process() {
    [..]
    // Store a callback and walk
    g_thing.onAfterWalk([]() {
        // Store another callback
        // After walking to 4321, 4321 do something else.
        // My actual problem... Callback within callback
        g_thing.onAfterWalk([]() { 
            std::cout << "Walking finished.\n";
        });

        // After walking to 1234, 1234 walk to 4321, 4321
        g_thing.walk(4321, 4321);
    });
    g_thing.walk(1234, 1234);
}

如何处理这种嵌套回调？

我应该创建一个std::stack 可能带有回调队列吗？最好的方法是什么？

Answer 1

对我有用（有一些调整：const 参数为onAfterWalk，最后std::cout.flush()）。你确定你不只是丢失标准输出中的输出吗？

#include <iostream>
#include <functional>

class Thing;
extern Thing g_thing;

class Thing
{
  std::function<void(void)> m_afterWalk;
public:
  void walk()
  {
    if(m_afterWalk)
    {
      m_afterWalk();
      m_afterWalk = nullptr;
    }
  }

  void onAfterWalk(const std::function<void(void)>& callback)
  {
    m_afterWalk = callback;
  }

  void process()
  {
    // Store a callback and walk
    g_thing.onAfterWalk([]() {
        // Store another callback
        g_thing.onAfterWalk([]() {
            std::cout << "Walking finished.\n";
        });
        g_thing.walk();
    });
    g_thing.walk();
  }
};

Thing g_thing;

int main(int argc, char *argv[])
{
  g_thing.process();
  std::cout.flush();
}

产量

$ g++ -pedantic -Wall -Werror test.cpp
$ ./a.out
Walking finished.