Función horquilla () en la progtwigción en C

Solo necesito entender esta statement:

if (fork() && !fork()) 

¿No debería ser siempre falso? Quiero decir, si escribo:

 if (a && !a) 

Siempre es falso, así que lo primero también debería ser falso, ¿me equivoco? Por supuesto que lo estoy, pero espero que alguien me pueda explicar esta cosa extraña.

Estoy estudiando C para un examen y tuve que resolver este código:

 int main(){ if(fork && !fork()){ printf("a\n"); } else printf("b\n"); } 

Cada llamada al sistema de creación de procesos unix llamada fork () devuelve dos veces. Primero regresa con el PID del hijo al padre (el proceso que llamó fork ()). En segundo lugar, vuelve a 0 para el niño recién creado.

de las páginas del manual:

Valor de retorno

En caso de éxito, el PID del proceso hijo se devuelve en el padre y 0 en el hijo. En caso de error, se devuelve -1 en el elemento primario, no se crea ningún proceso secundario y errno se establece correctamente.

en tu caso

 if (fork() && !fork()) 

La statement dentro de if , llama a fork dos veces. Entonces, lo que sucederá es lo siguiente:

 A |----------------B | | |---C | | | | 

Ahora la primera llamada a fork() regresará tanto en A como en B. En A será distinto de cero y en B será cero.

La segunda llamada a fork () será evocada solo de A. porque la primera fork devolvió 0 a B, no provocará una segunda fork() . es porque && cortocircuita la evaluación si se encuentra que el primer operando es distinto de cero. Gracias a Daniel por señalar esto.

Así que podemos hacer una tabla de esto:

 PID fork()1 fork()2 ------------------------------ A >0 >0 B =0 >0 C >0 =0 

Entonces, desde la tabla, el Proceso C if será evaluado a VERDADERO

Es importante recordar, fork()1 no regresó a C. Obtuvo la copia de Expresión ya evaluada de su padre.

Espero que esto explique tu pregunta.

En primer lugar, es una función. No siempre puede devolver el mismo valor.

En este caso específicamente, la bifurcación es una función que crea otro proceso. El proceso original obtiene un valor de retorno positivo (del pid del niño) y el proceso secundario obtiene un valor de retorno de 0.

En tu código, terminan siendo un total de tres procesos. La sentencia if se evaluará como verdadera para 1 de ellos (proceso C a continuación).

  A |__________B | | |__C | | | | | | | 
 shouldn't be always false? 

No.

Debido a que no es una variable, cada llamada a fork() crea un nuevo proceso hijo.

Cada llamada a fork() devuelve dos valores, uno para cada proceso. Entonces, para cada decisión, hay un proceso que toma cada camino.

La llamada a la función fork() devuelve 0 al proceso hijo y la ID del proceso al proceso padre. Básicamente, lo que esto hace es bifurcaciones una vez. Si el proceso es el principal, salta al siguiente bloque, el secundario vuelve a bifurcar. El padre de este proceso salta al siguiente bloque, y el niño en este bloque ejecuta el código en la sentencia if .