Bonjour,

Je suis actuellement entrain de réaliser une petite application pour m’entraîner et j'aurais besoin de me servir du système de threading ( c++11 ) pour effectuer cette opération :

- Mon main est appelé suite au lancement du programme et exécute les quelques bricoles qu'il doit faire, ce main contient également une boucle qui attend que l'utilisateur lui retourne une instruction comme par exemple sortir de la boucle pour terminer le programme.
- Avant que la boucle dans le main soit appelée, un thread doit être lancé et ce thread contient lui même une boucle infini et devra le rester tant que l'utilisateur n'aura pas confirmer une commande d’arrêt dans la fameuse boucle du main.

Dans la boucle de mon thread, il n'y a pas de fonction bloquante pour l'instant.

Ma question est donc, comment vous y prendriez-vous pour réaliser ceci ?

Je vois bien une solution plutôt simple à base de "std::thread" mais il faut en même temps que le thread qui exécute le programme en arrière plan sache quand il doit arrêter ses opérations proprement avant que le main soit rendu ( qu'importe ou en est le thread au moment de l’exécution de son programme, il doit pouvoir quitter à tout moment ). Je suppose donc que je dois me servir des mutex et de "std::lock_guard<>" ou "std::unique_lock<>" pour partager l'état entre le main et le second thread sans que le second thread ne puisse modifier l'état retourné par le main ?

J'ai lu cette documentation de 8 pages ( forte intéressante ) : http://www.justsoftwaresolutions.co....g-threads.html mais je dois avouer qu'après sa lecture, tout ça est un peu confus et j'ai encore du mal à comprendre quand utiliser quoi et pourquoi et de quelle manière. ( Mon niveau en Anglais médiocre n'a pas du arranger les choses ).

Si une âme charitable pouvez me remettre sur la piste avec quelques explications, je suis preneur.

Merci par avance pour toute aide apportée.