Exécution simultanée de deux programmes

J’ai deux programmes C ++ intégrés à Ubuntu et je veux les exécuter simultanément. Je ne veux pas les combiner en un seul projet C ++ et les exécuter sur un thread différent, car cela me cause toutes sortes de problèmes.

La solution que je veux réellement émuler, c’est lorsque j’ouvre deux tabs dans le terminal et que je lance chaque programme dans un onglet distinct. Cependant, je veux aussi un programme (appelons ce programme A) pour pouvoir quitter et relancer l’autre programme (programme B). Cela ne peut être réalisé que dans le terminal.

Donc, ce que je veux faire, c’est écrire du code C ++ dans le programme A, qui peut s’exécuter et quitter le programme B à tout moment. Les deux programmes doivent être exécutés simultanément, de sorte que le programme A n’a pas besoin d’attendre le retour du programme B avant de continuer avec le programme A.

Des idées? Merci!

Sous Linux, vous pouvez fork le processus actuel, ce qui crée un nouveau processus. Ensuite, vous devez lancer le nouveau processus avec un appel système exec .

Référez-vous à: http://man7.org/linux/man-pages/man2/execve.2.html

Par exemple:

 #include  /* for fork */ #include  /* for pid_t */ #include  /* for wait */ int main(int argc,char** argv) { pid_t pid=fork(); if (pid==0) { execv("/bin/echo",argv); } }

Vous avez plusieurs options ici:

Le traditionnel fork / exec de POSIX (il y a littéralement des tonnes d’exemples sur la façon de le faire dans SO, par exemple celui- ci).
Si vous pouvez utiliser Boost, le processus Boost est une option.
Si vous pouvez utiliser Qt, QProcess est une option.

Boost et Qt fournissent également de bons moyens pour manipuler les entrées / sorties standard du processus enfant si cela est important. Si ce n’est pas le cas, le moyen classique de POSIX devrait fonctionner correctement.

Jetez un coup d’oeil aux appels du système d’exploitation Linux, fork() et exec() . L’appel fork() créera deux copies du processus en cours qui continuent à s’exécuter simultanément.

Dans le processus parent, la valeur de retour de fork() correspond au PID (ID de processus) du processus enfant.
Dans le processus fils, la valeur de retour de fork() est 0.
En cas d’erreur, la valeur de retour de fork() est -1.

Vous pouvez l’utiliser à votre avantage pour contrôler le comportement du parent et de l’enfant. Par exemple:

 #include  #include  #include  #include  int main(int argc,char** argv) { char* progB = "/bin/progB"; char* args[progName, "arg1", "arg2", ..., NULL]; char* env[NULL]; // can fill in environment here. pid_t pid=fork(); if (pid==0) { // In child... execv(progB, args, env); } else if (pid == -1) { // handle error... } else { // In parent; pid is the child process. // can wait for child or kill child here. } }

Pour attendre que votre enfant quitte (dans le troisième cas ci-dessus), vous pouvez utiliser wait (2) , qui renvoie votre pid enfant en cas de succès ou -1 en cas d’erreur:

 pid_t result = waitpid(pid, &status, options);

Pour tuer votre enfant de manière préventive, vous pouvez envoyer un signal de suppression comme décrit dans kill (2) :

 int result = kill(pid, SIGKILL); // or whatever signal you wish

Cela devrait vous permettre de gérer vos processus comme décrit dans la question d’origine.