C++ &引用；执行；没有递归的语句体_C++_Loops_Recursion

C++ &引用；执行；没有递归的语句体

c++ loops recursion

C++ &引用；执行；没有递归的语句体,c++,loops,recursion,C++,Loops,Recursion,我试图通过对一个旧的家庭作业中{}范围内语句体的简化执行建模，来把握迭代和递归之间的关系。假设我有两种语句类型：while语句和赋值语句现在，我假设while语句的条件始终为true。 EDIT：另外，假设while语句只执行一次（即，我应该将其称为if语句）在递归中，这很简单： executeBody( body ) { for each stmt in body { switch (stmt) { case ASSIGNMENT: //

我试图通过对一个旧的家庭作业中{}范围内语句体的简化执行建模，来把握迭代和递归之间的关系。假设我有两种语句类型：while语句和赋值语句

现在，我假设while语句的条件始终为true。 EDIT：另外，假设while语句只执行一次（即，我应该将其称为if语句）

在递归中，这很简单：

executeBody( body )
{
  for each stmt in body
  {
    switch (stmt)
    {
      case ASSIGNMENT:
       // work
       break;

      case WHILE-STMT:
        executeBody(whileStmt->body)
        break;
    }
  }
}

但是，我在为迭代做这件事时遇到了麻烦。我知道我需要模拟一个堆栈，但在转到下一个语句之前，我无法概念化如何执行while语句中的所有语句。这是我的一个模型：

executeBody( body )
{
  for each stmt in body
  {
    case ASSIGNMENT:
      // work
      break;

    case WHILE-STMT:
    {
       stack< body > stack;
       stack.push(whileStmt->body);     
       while (stack isNotEmpty)
       {
          for each stmt (in each body) in stack
          {
            case ASSIGNMENT:
              // work;
              break;

            case WHILE-STMT:
              //stack.push(this_whileStmt->body);
              // ????
              break;
          }
       }
    }  
  }
}

执行体（正文）
{
对于体内的每个stmt
{
个案分配：
//工作
打破
案例WHILE-STMT：
{
堆栈stack；
堆栈.推送（whilesmt->body）；
while（堆栈不为空）
{
对于堆栈中的每个stmt（每个主体中）
{
个案分配：
//工作；
打破
案例WHILE-STMT：
//堆栈推送（此\u whilesmt->body）；
// ????
打破
}
}
}  
}
}

编辑：更改递归示例以显示主体是一系列语句。

堆栈位于错误的位置。它应该在executeBody例程的顶部声明。看看这个：

executeBody(body) {
    stack<body> work;

    stack.push(body);

    while (stack isNotEmpty) {
        item = stack.pop();
        switch (item) {
            case ASSIGNMENT:
                // work;
                break;
            case WHILE-STMT:
                stack.push(item);
                break;
        }
    }
}

执行体（正文）{
堆叠工作；
栈.推（体）；
while（堆栈不为空）{
item=stack.pop（）；
开关（项目）{
个案分配：
//工作；
打破
案例WHILE-STMT：
堆栈。推送（项目）；
打破
}
}
}

这个伪代码应该清楚地表明所有的身体都在堆栈上。他们有些做作业，有些做兼职。

首先，我要抛弃你的外环。这是多余的

   stack< body > stack;
   stack.push(body);     
   while (stack isNotEmpty)
   {
      for each stmt (in stack.pop()) // pop the top statement off of your stack
      {
        case ASSIGNMENT:
          // work;
          stmt.Remove()
          /*you don't need to break here.  just go onto the next operation*/

        case WHILE-STMT:
          stack.push(stmt->body);
          stmt.Remove()
          stack.push(stmt); 
          break;
      }

stackstack；
栈.推（体）；
while（堆栈不为空）
{
对于每个stmt（在stack.pop（）中）//从堆栈中弹出top语句
{
个案分配：
//工作；
stmt.Remove（）
/*你不需要在这里休息，继续下一个手术*/
案例WHILE-STMT：
堆栈推送（stmt->body）；
stmt.Remove（）
堆栈推送（stmt）；
打破
}

一旦您点击

WHILE-STMT:

案例，代码将中断并继续执行堆栈的顶部项目，这就是您刚才放在那里的代码块

一旦该块完成执行，它将从堆栈中弹出（您在

for

声明中执行此操作），它将与您的当前块一起恢复。清除当前语句并将工作块推回到堆栈上的整个目的就是为了能够像这样恢复。

是您发布的正确代码还是您自己的代码？是我自己的代码？这不正确，因为它没有完成将以

while（cond）开头cmd

，其中cmd可以是语句或块。然后维护一个cmd/cond/exec状态元组堆栈。当您点击while时，如果是cond，则推三元组。标准块推假cond。外部循环是推进堆栈上最上层的exec状态，获取cmd，handle。如果最上层完成，则检查cond和pop或重置exec状态。body是一个语句序列。我修改了递归示例，添加了一个for each and switch语句“在递归中，这将很简单”，或者可能不是。您只执行了一次while语句的主体，这是不完全正确的。在while STMT中，它应该读取stack.push（item->body），否则它会变成一个无限循环。一个小小的改变：你需要一个循环来迭代地将stmt项推送到堆栈中。原始的第二个代码片段表明，

body

是一个语句序列。你的代码没有对它进行任何形式的迭代，有些东西出了问题。谢谢你的评论-我只是想告诉你阐述堆栈应该用于整个例程的概念，而不仅仅是在case语句中。我不想深入钻研（但我确实理解这里提出的要点）。我不知道在执行循环后如何正确恢复。什么是

stmt.Remove（）

do？@phant0m不同于它将

while语句

视为普通的

代码块

（与OPs递归示例完全相同）你认为当它恢复时会发生什么？@phant0m应该从块中删除语句。根据实际实现，如果你不喜欢删除，可以将其标记为已执行，或者保留一个索引。我明白了，这是有意义的：+1