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

输出：53423122233445

我不明白此代码中发生的控制流导致上述输出。有人可以解释一下。提前谢谢你：）

Answer 1

我通过教导学生如何使用局部变量进行递归是最简单的理解方法是，如果你完全按照计算机的作用， - 逐步处理它，并记下调用的内容，以及变量值何时更改

例如：

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

您还需要了解每个函数调用中的内容，函数中对'n'的更改不会更改来自它的地方的价值。

如果您想象计算机执行以下操作，您可以更好地看到这一点：每个函数调用在堆栈上创建一组新变量，当函数返回时，其变量将从堆栈中删除。

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

依此类推，直到完成并打印出最后一个'5'。

Answer 2

如果我们对每个printf进行注释，这将变得更容易理解，以便我们可以告诉程序的哪个部分是什么数字。我也将把起始条件改为3，这样我们就可以完成整个过程了。

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

产生：

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

func1（3）打印3并调用func2（1）。
func2（1）打印1并调用func1（2）。
func1（2）打印2个调用func2（0）。
func2（0）立即返回。

现在我们已经触及了递归的底部。此时我们已经建立了一堆函数调用。

func1的（3）
FUNC2（1）
func1的（2）

一旦func2（0）返回，对func1（2）的调用将从中断处继续，我们从下往上完成堆栈。

func1（2）打印2并返回func2（1）。
func2（1）打印2，因为它增加了n，然后返回到func1（3）。
func1（3）打印3并返回main（）。
main（）返回，程序退出。

请解释这个C程序的工作原理

2 个答案: