C I'；我被“我的”中的递归弄糊涂了；“将十进制转换为二进制字符串”；代码

上面的代码返回“1000”。 但是当我将

print_binary（）

中的两行代码颠倒过来，然后这样写：

void print_binary(int number)
{
    if (number){
        print_binary(number/2);
        putc((number % 2) ? '1' : '0', stdout);
    }
}
int main(void) {
    print_binary(8);
}

void print_binary(int number)
{
    if (number){
        putc((number % 2) ? '1' : '0', stdout);  // 1st instruction
        print_binary(number/2); // 2nd instruction
    }
}

print_binary(8/2)
    print_binary(4/2)
        print_binary(2/2)
            print_binary(1/2)    // 1/2 = 0 => this is terminating condition of recursion
                                 // stack windup from here
            putc((1 % 2) ? '1' : '0', stdout);   --> output 1
        putc((2 % 2) ? '1' : '0', stdout);  --> output 0
    putc((4 % 2) ? '1' : '0', stdout);   --> output 0
putc((8 % 2) ? '1' : '0', stdout);    --> output 0

字符串是“0001”

---

我不明白为什么会这样。如有任何解释，我们将不胜感激。感谢您调用函数时，程序将当前地址放入堆栈内存中，堆栈指针指向堆栈内存，以便在执行结束时返回并跳转到函数的地址。 堆栈是后进先出（LIFO）结构，因此当您调用函数时，程序会在函数中完成指令，然后返回到原来的位置。这就是为什么要更改订单

void print_binary(int number)
{
    if (number){
        putc((number % 2) ? '1' : '0', stdout);
        print_binary(number/2);
    }
}

该程序的工作原理如下：

void print_binary(int number)
{
    if (number){
        print_binary(number/2);
        putc((number % 2) ? '1' : '0', stdout);
    }
}
int main(void) {
    print_binary(8);
}

void print_binary(int number)
{
    if (number){
        putc((number % 2) ? '1' : '0', stdout);  // 1st instruction
        print_binary(number/2); // 2nd instruction
    }
}

print_binary(8/2)
    print_binary(4/2)
        print_binary(2/2)
            print_binary(1/2)    // 1/2 = 0 => this is terminating condition of recursion
                                 // stack windup from here
            putc((1 % 2) ? '1' : '0', stdout);   --> output 1
        putc((2 % 2) ? '1' : '0', stdout);  --> output 0
    putc((4 % 2) ? '1' : '0', stdout);   --> output 0
putc((8 % 2) ? '1' : '0', stdout);    --> output 0

8%2为0，因此打印0。//第一审的第一条指令

一个新的功能出现了。跳转到它并将当前地址推送到堆栈//第1实例的2st指令

4%2为0，因此打印0//第二审的第一项指示

一个新的功能出现了。跳转到它并将当前地址推送到堆栈//第二审第二指示

2%2为0，因此打印第3个实例的0//1条指令

一个新的功能出现了。跳转到它并将当前地址推送到堆栈//第三个实例的第二个指令

1%2为0，因此打印第4个实例的1//1条指令

---

因此，在第一个代码示例中，输出为0001

，执行如下：

void print_binary(int number)
{
    if (number){
        print_binary(number/2);
        putc((number % 2) ? '1' : '0', stdout);
    }
}
int main(void) {
    print_binary(8);
}

void print_binary(int number)
{
    if (number){
        putc((number % 2) ? '1' : '0', stdout);  // 1st instruction
        print_binary(number/2); // 2nd instruction
    }
}

print_binary(8/2)
    print_binary(4/2)
        print_binary(2/2)
            print_binary(1/2)    // 1/2 = 0 => this is terminating condition of recursion
                                 // stack windup from here
            putc((1 % 2) ? '1' : '0', stdout);   --> output 1
        putc((2 % 2) ? '1' : '0', stdout);  --> output 0
    putc((4 % 2) ? '1' : '0', stdout);   --> output 0
putc((8 % 2) ? '1' : '0', stdout);    --> output 0

因此，输出为

1000

在第二个代码示例中，执行过程如下：

void print_binary(int number)
{
    if (number){
        print_binary(number/2);
        putc((number % 2) ? '1' : '0', stdout);
    }
}
int main(void) {
    print_binary(8);
}

void print_binary(int number)
{
    if (number){
        putc((number % 2) ? '1' : '0', stdout);  // 1st instruction
        print_binary(number/2); // 2nd instruction
    }
}

print_binary(8/2)
    print_binary(4/2)
        print_binary(2/2)
            print_binary(1/2)    // 1/2 = 0 => this is terminating condition of recursion
                                 // stack windup from here
            putc((1 % 2) ? '1' : '0', stdout);   --> output 1
        putc((2 % 2) ? '1' : '0', stdout);  --> output 0
    putc((4 % 2) ? '1' : '0', stdout);   --> output 0
putc((8 % 2) ? '1' : '0', stdout);    --> output 0

---

因此，输出是

0001

感谢链接，但我仍然很困惑，当函数中的两行交换时，输出是如何按顺序颠倒的。哇，非常感谢，非常简洁易懂！所以，当我调用我的函数时，它将值保存在堆栈中，然后使用堆栈结束进行计算。就说我还不习惯，哈哈，这对我来说太奇怪了。再次感谢！回答得很好。如果我不懒惰，我也会像你一样：）@H.S.我能再麻烦你一些吗？如果顺序是8->4->2->1，那么当putc（）时，顺序是1->2->4->8，这不是后进先出吗？我还以为这堆是先进先出的呢？@NamHoang似乎把你和后进先出和先进先出搞混了。了解。另外，你可能有兴趣阅读。@H.S.等等，下面有一个回复说stack是FIFO，而另一个人在原始帖子中说stack是FIFO，给我这个，结果他们错了？？我很好地理解了第二个，只是很难理解第一个是如何工作的。下面的评论救了我！也谢谢你的帮助！我以为stack就是后进先出？哈？你说得对。正如你们所注意到的，我在回答中提到的过程是后进先出行为。对不起，我头晕了，我编辑了它。