为什么这个程序打印＆＃34;分叉！＆＃34; 4次？

Question

为什么这个程序打印“分叉！”4次？

#include <stdio.h>
#include <unistd.h>

int main(void) {

  fork() && (fork() || fork());

  printf("forked!\n");
  return 0;
}

Answer 1

一个来自main()，另外三个来自fork()。

请注意，所有三个forks()都将被执行。您可能需要查看ref：

  

返回值

     

成功完成后， fork（）将向子进程返回0，并将子进程的进程ID返回给父进程 。两个进程都将继续从fork（）函数执行。否则，-1应返回到父进程，不应创建子进程，并设置errno以指示错误。

请注意，进程ID不能为零，如here所述。

---

那真的发生了什么？

我们有：

fork() && (fork() || fork());

因此，第一个fork()将向父级返回非零进程ID，而它将向子进程返回0。这意味着逻辑表达式的第一个fork将在父进程中被评估为true，而在子进程中它将被评估为false，并且由于Short circuit evaluation，它将不会调用剩余的两个fork() }第

所以，现在我们知道将至少获得两次打印（一次来自主打印，另一次来自第一次fork()）。

现在，父进程中的第二个fork()将被执行，它会执行，它会向父进程返回一个非零值，在子进程中返回一个零值。

所以现在，父进程不会继续执行到最后fork()（由于短路），而子进程将执行最后一个fork，因为||的第一个操作数是0。

这意味着我们将再获得两张照片。

因此，我们总共得到四张照片。

---

短路

这里，短路基本上意味着如果＆amp;＆amp;的第一个操作数。为零，则不评估其他操作数。在相同的逻辑上，如果是||的操作数是1，那么其余的操作数不需要评估。发生这种情况是因为其余的操作数不能改变逻辑表达式的结果，因此不需要执行它们，因此我们节省了时间。

见下面的例子。

---

<强>过程

请记住，父进程会创建后代进程，从而创建其他进程，依此类推。这导致了流程的层次结构（或者可以说是树）。

考虑到这一点，值得看看这个similar problem以及this回答。

---

描述性图片

我猜这个数字也可以提供帮助。我认为每次通话时返回的pid fork()分别为3,4和5。

请注意，某些fork()上面有一个红色的X，这意味着由于逻辑表达式的短路评估，它们不会被执行。

顶部的fork()不会被执行，因为运算符&&的第一个操作数是0，因此整个表达式将导致0，因此执行&&的其余操作数。

底部的fork()将不会被执行，因为它是||的第二个操作数，其第一个操作数是一个非零数字，因此表达式的结果已经被评估无论第二个操作数是什么，都是如此。

在下一张图片中，您可以看到流程的层次结构： 基于上图。

---

短路示例

#include <stdio.h>

int main(void) {

  if(printf("A printf() results in logic true\n"))
    ;//empty body

  if(0 && printf("Short circuiting will not let me execute\n"))
    ;
  else if(0 || printf("I have to be executed\n"))
    ;
  else if(1 || printf("No need for me to get executed\n"))
    ;
  else
  printf("The answer wasn't nonsense after all!\n");

  return 0;
}

输出：

A printf() results in logic true
I have to be executed

Answer 2

第一个fork()在调用进程中返回一个非零值（称之为p0），在子节点中返回0（称之为p1）。

在p1中，&&采用短路，进程调用printf并终止。在p0中，该过程必须评估表达式的其余部分。然后它再次调用fork()，从而创建一个新的子进程（p2）。

在p0 fork()中返回非零值，并且||的短路线被采用，因此进程调用printf并终止。

在p2中，fork()返回0，因此||的其余部分必须进行评估，这是最后一次fork();这导致为p2创建一个孩子（称之为p3）。

P2然后执行printf并终止。

然后

P3执行printf并终止。

然后执行4 printf。

Answer 3

^{对于所有的downvoters来说，这是一个合并但不同的问题。责备SO。谢谢。}

您可以将问题分解为三行，第一行和最后一行都只是将进程数加倍。

fork() && fork() || fork();

操作员正在短路，所以这就是你得到的：

       fork()
      /      \
    0/        \>0
 || fork()     && fork()
     /\            /   \
    /  \         0/     \>0
   *    *     || fork()  *
                /   \
               *     *

所以这总共是4 * 5 = 20个进程，每个进程打印一行。

注意：如果由于某种原因fork（）失败（例如，你对进程数有一些限制），它会返回-1然后你会得到不同的结果。

Answer 4

执行fork() && (fork() || fork())，会发生什么

每个fork给出2个进程，分别为pid（parent）和0（child）

First fork：

• 父回车值是pid not null =＆gt;执行&& (fork() || fork())
  • 第二个fork父值是pid not null停止执行|| part =＆gt;打印forked
  • second fork child value = 0 =＆gt;执行|| fork()
    • 第三叉父母打印forked
    • 第三叉子邮件forked
• 子返回值为0停止执行＆amp;＆amp; part =＆gt;打印forked

总计：4 forked

Answer 5

我喜欢已经提交的所有答案。也许如果你在printf语句中添加了一些变量，你就会更容易看到发生了什么。

#include<stdio.h>
#include<unistd.h>

int main(){

   long child = fork() && (fork() || fork());
   printf("forked! PID=%ld Child=%ld\n", getpid(), child);
   return 0;
}

在我的机器上产生了这个输出：

forked! PID=3694 Child = 0
forked! PID=3696 Child = 0
forked! PID=3693 Child = 1
forked! PID=3695 Child = 1

Answer 6

此代码：

fork();
fork() && fork() || fork();
fork();

自己获得20个进程，而Printf将进行20次。

而

fork() && fork() || fork();

printf将共进行5次。