1

我很困惑递归在这个例子中是如何工作的。如果输入'ABC\n'，则输出CBA。如果有人可以逐步完成该过程，我将不胜感激。

  1. 在 main() 中，调用了 ReverseLine()

  2. 本地自动 myInput 接受 'ABC\n'

  3. 然后它检查 myInput 的 '\n' 和 EOF，这就是我开始感到困惑的地方

我认为它说， A != '\n' 和 A != EOF 所以 ReverseLine() 再次被调用，但是然后呢？？？

递归是如何工作的，我只是想了解一下过程

谢谢

    using namespace std;

    void ReverseLine(){
       int myInput;

       myInput = cin.get();

       if (myInput != '\n' && myInput != EOF)
        ReverseLine();

       if (myInput != EOF)
        cout.put(myInput);
    }

    int main(){

       ReverseLine();
       return 0;

    }
4

4 回答 4

4

当您调用 ReverseLine 时，它​​会读取一个字符。如果字符不是换行符或 EOF，它会再次调用自身（递归）以读取下一个字符，直到遇到换行符，此时它打印刚刚读取的字符，然后返回到 ReverseLine 打印它读取的字符和以此类推，直到它返回对 ReverseLine 的初始调用，打印读取的第一个字符，然后退出。

于 2012-10-06T18:52:07.320 回答
4

也许扩展它会帮助你理解？

void ReverseLine() {
   int myInput = 'a'

   if (myInput != '\n' && myInput != EOF) {
       int myInput = 'b'

       if (myInput != '\n' && myInput != EOF) {
           int myInput = 'c'

           if (myInput != '\n' && myInput != EOF) {
               int myInput = '\n'
               if (myInput != '\n' && myInput != EOF)
                   ReverseLine(); // doesn't get called
               cout.put(myInput);
           }
           if (myInput != EOF)
               cout.put(myInput);
       }

       if (myInput != EOF)
        cout.put(myInput);
   }

   if (myInput != EOF)
    cout.put(myInput);
}
于 2012-10-06T18:51:28.027 回答
2

正如 Basile 所说，递归可能很难理解。这个例子依赖于局部变量的概念。它将到达递归层的末尾，然后开始打印myInput从最深递归调用到第一个的局部变量。

假设您输入“123”。每个缩进都是ReverseInput().

myInput = 1
ReverseLine()
  myInput = 2
  ReverseLine()
    myInput = 3
    ReverseLine()
      myInput = \n
    prints 3
  prints 2
prints 1

这是以相反方式做事的常见技巧。

于 2012-10-06T18:55:35.810 回答
1

这真的很简单。ReverseLine 函数在返回之前打印其输出。这是事件的顺序，如果输入* ABC\n

1. First call to ReverseLine.
1.a **A** is typed.
1.b myInput is not equal to **\n or EOF**, so
   2. Second call to ReverseLine
   2.a **B** is typed.
   2.b myInput is not equal to **\n** or **EOF**, so
      3. Third call to ReverseLine
      3.a **C** is typed.
      3.b myInput is not equal to **\n** or **EOF**, so
         4. Fourth call to ReverseLine
         4.a **\n** is typed.
         4.b myInput is equal to **\n**, so
         4.c ReverseLine is **not** called
         4.d myInput is **not** equal to **EOF**, so
         4.e myInput (**\n**) is printed
         4.f Fourth call to ReverseLine returns
      3.c myInput is **not** equal to **EOF**, so
      3.d myInput (**C**) is printed
      3.e Third call to ReverseLine returns
   2.c myInput is **not** equal to **EOF**, so
   2.d myInput (**B**) is printed
   2.e Second call to ReverseLine returns
1.c myInput is **not** equal to **EOF**, so
1.d myInput (**A**) is printed
1.e First call to ReverseLine returns

然后程序结束。

于 2012-10-06T19:00:35.727 回答