1.写出下面程序的运行结果 #include <stdio.h> void Bin(int x) { if (x/2 > 0) Bin(x/2); printf("%d ", x%2); } int main() { Bin(12); return 0; } A. 1 1 0 0​B.6 3 1 1 ​ C. 6 3 1 0 D. 0 0 1 1

C. 6 3 1 0

程序的运行过程如下：

1. main 函数调用 Bin(12)。

2. Bin 函数的第一次递归调用 Bin(6)，因为 12/2 = 6。

3. Bin 函数的第二次递归调用 Bin(3)，因为 6/2 = 3。

4. Bin 函数的第三次递归调用 Bin(1)，因为 3/2 = 1。

5. Bin 函数的第四次递归调用 Bin(0)，因为 1/2 = 0。

6. 此时 Bin 函数开始返回，依次输出每个调用中 x%2 的值，即 0 1 1 0。

因此程序的输出结果为 6 3 1 0。

相关问题

#include <stdio.h> void Bin(int x) { if (x/2 > 0) Bin(x/2); printf("%d\n", x%2); } int main() { Bin(12); return 0;

这是一个递归函数，用于将十进制整数转换为二进制。函数的输入参数为一个十进制整数x，输出为其对应的二进制数。主函数中调用了Bin函数，将12作为参数传入。

函数首先判断x/2是否大于0，如果是，则递归调用Bin函数，传入x/2作为参数，直到x/2不大于0为止。然后，函数输出x%2的值，即x除以2的余数。这个余数要么是0，要么是1，表示二进制数的某一位。

具体来说，函数的执行过程如下：

1. Bin(12)调用时，x=12，12/2=6>0，因此执行Bin(6)。
2. Bin(6)调用时，x=6，6/2=3>0，因此执行Bin(3)。
3. Bin(3)调用时，x=3，3/2=1>0，因此执行Bin(1)。
4. Bin(1)调用时，x=1，1/2=0，不满足条件，直接输出1%2=1，表示二进制数的最低位。
5. 回到Bin(3)函数，输出3%2=1，表示二进制数的第二位。
6. 回到Bin(6)函数，输出6%2=0，表示二进制数的第三位。
7. 回到Bin(12)函数，输出12%2=0，表示二进制数的最高位。

因此，函数输出的二进制数为1100。

# include<stdio.h> # include<signal.h> # include<unistd.h> void waiting(); void stop(); int main(void) { int p1, p2; signal(SIGINT,stop); while((p1=fork())= =-1); if(p1>0)

{
while((p2=fork())==-1);
if(p2>0)
{
waiting(); // 等待子进程结束
kill(p2, SIGKILL); // 终止子进程p2
}
else if(p2==0)
{
execl("/bin/sh", "sh", "-c", "echo child process 2; exit 0", (char*)0);
}
}
else if(p1==0)
{
execl("/bin/sh", "sh", "-c", "echo child process 1; exit 0", (char*)0);
}
return 0;
}

void waiting()
{
printf("Waiting for child processes to finish...\n");
sleep(5);
}

void stop()
{
printf("Received SIGINT signal, terminating all child processes...\n");
kill(0, SIGKILL); // 终止所有进程组
}

这是一个简单的在Linux系统下使用fork实现多进程的程序，并且在父进程接收到SIGINT信号时，终止所有子进程的程序段。