Fourche parent-enfant de la communication

(Je vais partir du principe que nous parlons de linux ici)

Comme vous l'avez probablement constaté, fork() lui-même va juste dupliquer le processus appelant, il ne gère pas les CIB.

De fourche manuel:

fork() crée un nouveau processus par dupliquer le processus appelant.
Le nouveau processus, appelé l'enfant, est une copie exacte de
le processus appelant, désigné comme parent.

La façon la plus commune pour gérer l'IPC une fois que vous fourchue() est d'utiliser des tuyaux, surtout si vous voulez "privé de comunication chanel avec chaque enfant". Voici un typique exemple facile d'utilisation, semblable à celui que vous pouvez trouver dans le pipe manuel (valeurs de retour ne sont pas vérifiées):

   #include <sys/wait.h>
   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   #include <string.h>

   int
   main(int argc, char * argv[])
   {
       int pipefd[2];
       pid_t cpid;
       char buf;

       pipe(pipefd); //create the pipe
       cpid = fork(); //duplicate the current process
       if (cpid == 0) //if I am the child then
       {
           close(pipefd[1]); //close the write-end of the pipe, I'm not going to use it
           while (read(pipefd[0], &buf, 1) > 0) //read while EOF
               write(1, &buf, 1);
           write(1, "\n", 1);
           close(pipefd[0]); //close the read-end of the pipe
           exit(EXIT_SUCCESS);
       }
       else //if I am the parent then
       {
           close(pipefd[0]); //close the read-end of the pipe, I'm not going to use it
           write(pipefd[1], argv[1], strlen(argv[1])); //send the content of argv[1] to the reader
           close(pipefd[1]); //close the write-end of the pipe, thus sending EOF to the reader
           wait(NULL); //wait for the child process to exit before I do the same
           exit(EXIT_SUCCESS);
       }
       return 0;
   }

Le code est assez explicite:

1. Parent fourches()
2. Lit enfant() de la conduite jusqu'à ce que EOF
3. Parent écrit() à la pipe puis se ferme() il
4. Données ont été partagées, hourra!

À partir de là, vous pouvez faire ce que vous voulez; n'oubliez pas de vérifier vos valeurs de retour et de lire dup, pipe, fork, wait... manuels, ils vous seront utiles.

Il y a aussi un tas d'autres façons de partager les données entre les processus, ils mlgh vous intéresser, même s'ils ne répondent pas à vos "privé" exigence:

• mémoire partagée "SHM", le nom dit tout...
• sockets, évidemment, travailler comme bonne si elle est utilisée localement
• FIFO fichiers qui sont en fait des tubes avec un nom

ou même un simple fichier... (je l'ai même utilisé SIGUSR1/2 les signaux pour envoyer des données binaires entre les processus une fois... Mais je ne recommande pas que haha.)
Et probablement un peu plus que je n'y pense pas sur le moment présent.

Bonne chance.