c
 


 

 



  

Estamos tan acostumbrados a que ciertas cosas funcionen que no nos paramos a pensar
como pueden hacerlo. Por ejemplo, con el siguiente código:

p
 

  
p
  

  
p
 p
   
p
p
  

aenemos en aquí solo 2 llamadas al sistema:

¦Ê 
: cierra un descriptor de fichero
¦Ê : duplica un descriptor de fichero, si tenemos un determinado
descriptor apuntando a, por decir algo, /dev/null mediante dup se crea uno nuevo
apuntando igualmente a /dev/null

Mi primera reacción ante el código anterior fue:

WhataheFrak?!?!?!

Como apreciamos las llamadas  vistas independientemente no tienen sentido

porque no guarda en ninguna parte el nuevo descriptor:

  

Pero si la vemos con la llamada anterior si que cobra sentido:

p
 
Porque con el 
 liberamos un descriptor, por lo que sabemos que el 
devolverá el descriptor de fichero que se acaba de liberar (0: ), por lo que
podemos cerrar el descriptor que tenemos como pipe1[0] porque a la pipe ya apunta el
nuevo descriptor, el 0, el cual además es el . Podemos comprobarlo con el
siguiente código:

ÿp

  
ÿp
 
 


  

  
  
 

!

Como que los ,  y  ya están abiertos el  nos devolverá
el 3:

"

 
#

Pero si cerramos primero el  antes del  (en el ) nos devolverá un 0:

p
 
 
  

£iendo el resultado el esperado:

"

 


Lo mismo que aplica a la función  aplicaría a la función  .

En este sentido podemos imaginar como un interprete de comandos traduce la siguiente

instrucción de comandos a procesos:

$
 %p


£e traduce en el siguiente código:

ÿp

  
ÿp
p  


  

 

 

 
&'' 
 
  p
 
 
 
  p
  
 
p
 ()*+,-.$()/+(012$().+30* 
  p
p
  
  4p 
 
  % 0311
 !

 
&'' 
 
  p
  
 
  
  p
 
  p
p
  
  4p     0311 
 !

 

!

ºónde:

¦Ê El primer hijo, el
, usa como  la  y como  el  
¦Ê El segundo hijo el
, no necesita de , y la  usa la 

Por lo que efectivamente podemos ver que los resultados son equivalentes:

5ppp 
"

 
pp

p
p


p




Comparados con el comando:

 $
 %p


pp

p
p


p



Ê