C++遞歸堆棧

Question

我很困惑遞歸在這個例子中如何工作。如果輸入'ABC \ n'，則輸出CBA。如果有人能夠通過這個過程，我將不勝感激。

1. 在main（），ReverseLine（）被調用

2. 本地automtic myInput取入 'ABC \ N'

3. 然後檢查myInput關於 '\ n' 和EOF，這就是我開始越來越困惑

我認爲它說，A！= '\ n' 和阿！= EOF所以ReverseLine（）再次調用，但然後呢???

如何遞歸的工作，我只是想了解的過程

THANKS

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

當您調用ReverseLine時，它會讀取一個字符。如果字符不是換行符或EOF，它會再次調用自身（遞歸）讀取下一個字符，直到遇到新行，此時它會打印剛剛讀取的字符，然後返回到ReverseLine，它會打印它讀取的字符並直到它返回到ReverseLine的初始調用，打印第一個讀取的字符，然後退出。

Answer 2

也許擴展它會幫助你明白嗎？

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 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 

鍵入然後程序結束。