C ++递归堆栈

Question

在本示例中，我很困惑递归的工作方式。 如果输入“ 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;

    }

Answer 1

也许扩展它可以帮助您理解？

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);
}

Answer 2

当您调用ReverseLine时，它将读取一个字符。 如果该字符不是换行符或EOF，它将再次调用自身（递归）以读取下一个字符，直到遇到换行符为止，在该点处将打印出刚刚读取的字符，然后返回到ReverseLine，从而打印出其读取的字符并依此类推，直到返回到ReverseLine的初始调用，打印读取的第一个字符，然后退出。

Answer 3

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

假设您输入“ 123”。 每个缩进都是ReverseInput()的新局部范围。

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

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

Answer 4

这真的非常简单。 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

然后程序结束。