Bonjour à tous,
En révisant mon examen de système, je suis tombé sur le programme suivant qui sert a renvoyer les nombres premiers entre 2 et n (une borne supérieure passé en paramètre).
En revanche, j'ai du mal a comprendre son fonctionnement, une aide serait vraiment la bienvenue...
(j'ai mis que le principal, exit certains tests et messages d'erreurs correspondants)
Code c : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 int main(int argc, char** argv) { int borne = atoi(argv[1]); int tube[2]; pid_t fils; pipe(tube); switch (fils = fork()) { case 0: crible(tube); exit(0); break; default: close(tube[0]); for (int i=2 ; i<=borne ; i++) { write(tube[1], (void*)&i, sizeof(int)); } close(tube[1]); wait(0); return 0; break; } }
Donc d'après ce que je comprends (arrêtez moi si je me trompe), dans le main, on crée un processus fils et on envoi a ce dernier tous les nombres compris entre 2 et la borne supérieure (le argv[1] passé).
J'ai 2 questions:
- Pourquoi ferme-on la sortie du tube quand on est dans le processus père?
- Pourquoi caste-on l'entier i en void*?
Code c : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 void crible(int *in) { int P; read(in[0], (void*)&P, sizeof(int)); printf("%d", P); int out[2]; pipe(out); pid_t fils; fils = fork(); switch (fils) { case 0: close(in[0]); crible(out); exit(0); break; default: close(out[0]); int i; while (read(in[0], (void*) &i, sizeof(int)) == sizeof(int)) { if (i % P) { write(out[1], (void*) &i, sizeof(int)); } } close(in[0]); close(out[1]); return; break; } }
Et c'est la que ca se corse pour moi... Ce que j'ai compris (ou du moins ce que je pense avoir compris):
- La fonction crible recoit un tube, et lit le premier nombre (P) en entrée et l'affiche. (file?)
- Création d'un second tube et d'un processus fils
- Si on est dans le processus père, on lit les nombres présents (i) dans le tube passé en paramètre, si i%P != 0 alors on conserve le i et on l'écrit dans le second tube
- Si on est dans le fils, on rappelle la fonction avec le second tube => récursivité: a chaque passage on élimine les nombres divisibles par P
Même questions que ci dessus? Pourquoi ces (void*) et ces closes?
Autre question: un tube fonctionne comme une file?
Quand je fais :
Code c : Sélectionner tout - Visualiser dans une fenêtre à part read(in[0], (void*)&P, sizeof(int));
Elle "défile" le premier, et le tube conserve tous les autres nombres?
Merci a ceux qui m'ont lu.
Et un grand merci à ceux qui relèveront mes erreurs, et répondront a mes questions.
Bonne soirée.
Partager