C++ 递归到保留变量和调用顺序的迭代

我有一个非常复杂的代码要从递归转换到迭代。我不知道如何使用这种代码：

read(std::queue<int>& rules, std::queue<double>& data)
{
  int r = rules.top();
  rules.pop();
  switch(r)
  {
    case 1:
    {
      double a = data.front(); data.pop();
      read(rules, data);
      double b = data.front(); data.pop();
      read(rules, data);
      double c = a + b;
      data.push(c);
    }
    break;
    case 2:
    {
      read(rules, data);
      data.pop();
    }
    break;
    case 3:
    {
      data.push(0.0);
    }
  }
}

读取（标准：：队列和规则，标准：：队列和数据）
{
int r=rules.top（）；
rules.pop（）；
开关（r）
{
案例1：
{
双a=data.front（）；data.pop（）；
读取（规则、数据）；
双b=data.front（）；data.pop（）；
读取（规则、数据）；
双c=a+b；
数据推送（c）；
}
打破
案例2：
{
读取（规则、数据）；
data.pop（）；
}
打破
案例3：
{
数据推送（0.0）；
}
}
}

---

我不知道如何在这种情况下开始…

标准方法是使用显式堆栈作为局部变量来模拟递归堆栈

struct Task {
  int caseValue; /* 1, 2, 3 */
  std::queue<int>& rules;
  std::queue<double>& data;
  void execute(std::stack<Task>& agenda)
     { // do one thing and put next tasks in the agenda
       // by using agenda.push_back
     }
};
typedef std::stack<Task> Agenda;
void read(...) {
  Agenda agenda;
  int r = rules.top();
  rules.pop();
  agenda.push_back(Task(r, rules, data));
  while (!agenda.empty()) {
    Task task = agenda.top();
    agenda.pop_back();
    task.execute(agenda);
  };
}

struct任务{
int caseValue；/*1,2,3*/
std：：队列和规则；
std：：队列和数据；
无效执行（标准：：堆栈和议程）
{//做一件事，把下一个任务列入议程
//使用agenda.push_返回
}
};
typedef std：：堆栈议程；
无效读取（…）{
议程；
int r=rules.top（）；
rules.pop（）；
议程。推回（任务（r、规则、数据））；
而（！agenda.empty（））{
Task=agenda.top（）；
议程。返回；
任务.执行（议程）；
};
}

这里，议程模拟了递归堆栈。迭代版本可能效率较低，但可能会简化调试，因为您可以在while循环中设置断点。

可能会有所帮助