#include
#include
#include

int main()
{
pid_t pid;
int status;

//apelul fork()
pid=fork();

switch(pid)
{
case 0:
//aici ne aflam in procesul copil
printf("PID fiu:%d\n",getpid());
return 0;
break;

case -1:
//eroare
//ar fi bine daca s-ar face si tratarea erorii :)
break;
default:
//aici ne aflam in procesul parinte

//asteptam intai sa se termine procesul copil
wait(&status);

//tiparim mesajul
printf("PID parinte:%d\n",getpid());

}
return 0;
}

Observatii:
1)
 Se vede ca in switch(pid) , cand ma aflu in procesul copil la sfarsitul
 sectiunii case corespunzatoare (case 0) folosesc inainte de break
apelul return.Aceasta imi asigura ca dupa apelul fork procesul copil
executa NUMAI ce se afla intre case 0: si apelul return , asigurand
astfel terminarea procesului copil. Din cauza ca se copiaza zona de cod a
 procesului parinte in procesul fiu , dupa iesirea din switch() , ambele
 procese vor executa aceleasi instructiuni. In exemplul de fata , nu se
mai executa decat return , deci s-ar fi putut si fara return la procesul
 copil. Daca programul ar contine o bucla in care se face un fork , daca
 procesul copil nu se termina , ar putea rezulta ceea ce se numeste un
fork-bomb , programul generand la infinit noi procese , care vor provoca
 in cele din urma o blocare a sistemului de operare.

2)S-a folosit functia wait:
pid_t wait(int *status);
pentru
 a astepta terminarea procesului copil. Daca nu se face wait , procesele
 copil terminate vor fi inca prezente in sistemul de operare ca defuncte
 sau zombie. Daca vreti sa vedeti cum se manifesta asta faceti mai multe
 procese pe care nu le asteptati cu wait() si urmariti procesele pornite
 din sistem. Functia wait asteapta terminarea oricarui proces copil ,
dupa care in "status" se pot regasi informatii despre codul de return al
 procesului fiu si alte chestii interesante. Pentru a astepta terminarea
 unui anumit proces , se foloseste waitpid:
pid_t waitpid(pid_t pid,int *status,int options);
care asteapta terminarea procesului cu PID-ul pid. Pentru mai multe informatii consultati paginile man din Linux.

Pentru a intoarce PID-ul procesului curent avem functia:
pid_t getpid(void);
Pentru a intoarce PID-ul procesului parinte avem functia:
pid_t getppid(void);

ATENTIE!!!
Din
 cauza faptului ca dupa apelul fork se copiaza sectiunea de date a
procesului parinte in procesul fiu , orice modificare asupra unei
variabile declarata inainte de fork() intr-un proces nu va fi sesizata
in celalalt proces. Daca explicatia de mai sus pare un pic imbarligata ,
 sa luam un exemplu:

Declaram niste variabile:
int a=0,b=10,status;
pid_t pid;

pid=fork();

switch(pid)
{
case 0:
a++;
b--;
return;
break;
case -1:
break;
default:
wait(&status);
a--;
b++;
}
Greseala
 pe care eu am facut-o prima data cand am lucrat cu procese a fost ca
avem impresia ca daca modific o variabila intr-un proces , si celalalt
proces sesizeaza asta; din cauza copierii sectiunilor de date , fiecare
proces lucreaza asupra propriilor variante ale fiecarei variabile , deci
 rezultatele operatiilor sunt independente. In urma executarii
exemplului de mai sus , procesul parinte va avea a=-1 , b=11 in timp ce
procesul copil va avea a=1 , b=9. Pentru ca procesele sa partajeze zone
din sectiunea de date se poate folosi apelul clone (man clone pentru
detalii).

Chiar daca in urma apelului fork nu se poate comunica
direct intre procesele create, sistemul de operare pune la dispozitie o
serie de mecanisme de comunicare interproces (pipe-uri , memorie
partajata , semafoare , cozi de mesaje) , care vor fi detaliate pe
parcursul tutorialelor de aici.