Bitte erläutern Sie die Funktionsweise dieses C-Programm

Question

#include<stdio.h> 

void func1(int n) 
{ 
    if(n==0) return; 
    printf("%d",n); 
    func2(n-2); 
    printf("%d",n); 
} 

void func2(int n) 
{ 
    if(n==0) return; 
    printf("%d",n); 
    func1(++n); 
    printf("%d",n); 
} 

void main() 
{ 
    func1(5); 
} 

Ausgang: 53423122233445

Ich verstehe nicht, den Fluss der Steuerung, die auf die obige Ausgabe in diesem Code geschieht führt. Kann mir bitte jemand erklären. Vielen Dank im Voraus :)

Answer 1

Dies wird leichter zu verstehen, wenn wir jedes printf kommentieren, so dass wir sagen können, welche Nummer von welchem ​​Teil des Programms ist. Ich werde auch die Startbedingung auf 3 ändern, damit wir durch die ganze Sache gehen können.

#include <stdio.h> 

void func2(int); 

void func1(int n) 
{ 
    if(n==0) return; 
    printf("func1 before: %d\n",n); 
    func2(n-2); 
    printf("func1 after: %d\n",n); 
} 

void func2(int n) 
{ 
    if(n==0) return; 
    printf("func2 before: %d\n",n); 
    func1(++n); 
    printf("func2 after: %d\n",n); 
} 

int main() 
{ 
    func1(3); 
} 

Das erzeugt:

func1 before: 3 
func2 before: 1 
func1 before: 2 
func1 after: 2 
func2 after: 2 
func1 after: 3 

1. func1 (3) druckt 3 und ruft func2 (1).
2. func2 (1) druckt 1 und ruft func1 (2) auf.
3. func1 (2) druckt 2 Anrufe func2 (0).
4. func2 (0) kehrt sofort zurück.

Jetzt haben wir das Ende der Rekursion erreicht. An dieser Stelle haben wir einen Stapel von Funktionsaufrufen aufgebaut.

1. func1 (3)
2. func2 (1)
3. func1 (2)

Sobald func2 (0) zurückkehrt, wird der Anruf zu func1 (2) aufnimmt, wo sie aufgehört haben und wir arbeiten von unten nach oben durch den Stapel.

5. func1 (2) druckt 2 und kehrt zu func2 (1) zurück.
6. func2 (1) druckt 2, weil es n erhöht hat und zu func1 (3) zurückkehrt.
7. func1 (3) druckt 3 und kehrt zu main() zurück.
8. main() kehrt zurück und das Programm wird beendet.

Answer 2

Ich habe durch Lehre Studenten gefunden, wie Rekursion mit lokalen Variablen funktioniert ist, dass der einfachste Weg, es zu verstehen ist, wenn man genau das tun, was der Computer tut, - Prozess es Schritt für Schritt, und aufschreiben, was aufgerufen wird und wenn Variablenwerte

zum Beispiel ändern:

main 
    func1(5) 
    n=5 
    printf 5 
    func2(5-2) 
     n=3 
     print 3 
     ++n 
     n=4 
     func1(4) 
     n=4 
     print 4 
     func2(4-2) 
      n=2 
      print 2 
      ++n 
      n=3 
      func1(3) 
      n=3 
      print 3 
      func2(3-2) 
       n=1 
       print 1 
       ++n 
       n=2 
       func1(2) 
       n=2 
       print 2 
       func2(2-2) 
        n=0 
        if n==0 => return 
       print 2 
       print 2 
      print 3 
      print 3 
     print 4 
     print 4 
    print 5 
    //done 

Sie müssen auch innerhalb der einzelnen Funktionsaufrufes verstehen, dass, die Änderungen an ‚n‘ innerhalb einer Funktion nicht die früheren ändern Wert von wo es aufgerufen wurde.

Sie können dies besser sehen, wenn Sie den Computer so etwas wie dies vorstellen: wo jeder Funktionsaufruf eine neue Reihe von Variablen auf dem Stapel, und wenn eine Funktion zurückgibt, seine Variablen gelöscht werden aus dem Stapel erstellt.

stack: (empty) 

main 
    func1(5) ==> push n='5' on stack, then jump to func1() 
    stack is now { n=5 } 
    so n is 5 
    print 5 
    func2(5-2) ==> push 'n=3' on stack, then jump to func2() 
     stack is now { n=3 } , { n=5 } 
     so n is 3 
     print 3 
     ++n 
     stack is now { n=4 } , { n=5 } 
     func1(4) ==> push 'n=4' on stack then jump to func1() 
     stack is now { n=4} , { n=4 } , { n=5 } 
     so n is 4 
     print 4 
     func2(4-2) ==> push 'n=2' on stack then jump to func() 
      stack is now {n=2}, {n=4} , { n=4 } , { n=5 } 
      ++n 
      stack is now {n=3}, {n=4} , { n=4 } , { n=5 } 
      ...etc... 
      ..... 
      .... 
      stack is eventually {n=0} {n=2}, {n=2}, {n=2} ,{n=1} {n=3}, {n=3}, {n=4} , { n=4 } , { n=5 } 
      after func(2-2) is called 
      then: 
       if n==0 => return; 
      the return pops one item {n=0} off the stack, so 
      stack is then {n=2}, {n=2}, {n=2} ,{n=1} {n=3}, {n=3}, {n=4} , { n=4 } , { n=5 } 
      print 2 
      return (deletes {n=2}) 
      stack is then {n=2}, {n=2} ,{n=1} {n=3}, {n=3}, {n=4} , { n=4 } , { n=5 } 
      print 2 
     return (deletes {n=2}) 
     stack is then {n=2} ,{n=1} {n=3}, {n=3}, {n=4} , { n=4 } , { n=5 } 
     print 2 
     return (deletes {n=2}) 
    stack is then {n=1} {n=3}, {n=3}, {n=4} , { n=4 } , { n=5 } 
    print 1 
    return (deletes {n=1}) 
    stack is then {n=3}, {n=3}, {n=4} , { n=4 } , { n=5 } 
    print 3 

und so weiter, bis er abgeschlossen ist und die letzte ‚5‘ wird ausgedruckt.