HOWTO · C++
exit(1) en C++
Cet article montre comment utiliser la fonction de sortie en C++
Sur cette page
En règle générale, exit(1) termine un programme C++ avec un statut non nul, ce qui signale un échec à l’environnement appelant. Un statut égal à zéro signale conventionnellement une réussite. En C++, la fonction std::exit est déclarée dans <cstdlib> ; utilisez EXIT_SUCCESS et EXIT_FAILURE comme valeurs de statut standard. Il est généralement préférable de retourner depuis main, car les objets locaux peuvent alors être détruits normalement.
Ce que fait std::exit en C++
La fonction std::exit prend un statut entier et termine le programme sans retourner à son appelant. L’écriture courante exit(1) désigne la fonction de la bibliothèque C ; en C++, utilisez le nom qualifié std::exit pour préciser son espace de noms. Les constantes EXIT_SUCCESS et EXIT_FAILURE expriment les statuts standard de réussite et d’échec sans supposer de valeur numérique particulière pour l’échec.
Une terminaison normale via std::exit appelle les fonctions enregistrées avec std::atexit, détruit les objets à durée de stockage statique et vide puis ferme les flux C. Elle ne dépile pas la pile d’appels en cours : les objets automatiques de la fonction qui appelle std::exit ne sont donc pas détruits. C’est important lorsque ces objets possèdent des ressources dont la libération dépend de leur destructeur.
Utiliser std::exit avec un code de statut
Utilisez std::exit(EXIT_SUCCESS) lorsqu’une fonction située hors de main doit terminer tout le programme avec succès, même s’il est généralement plus simple de raisonner en retournant un statut depuis main. Exécutez cet exemple ; le texte affiché, Operation completed, reste en anglais, car le bloc de code et sa sortie sont conservés à l’identique :
#include <cstdlib>
#include <iostream>
int main() {
std::cout << "Operation completed" << '\n';
std::exit(EXIT_SUCCESS);
}
Operation completed
En cas d’erreur fatale qui ne permet aucune récupération utile, signalez le problème puis terminez avec std::exit(EXIT_FAILURE). Ce programme autonome utilise --fail pour sélectionner cette voie ; sans cet argument, il se termine normalement. Le diagnostic est écrit sur la sortie d’erreur standard ; le texte affiché dans les exemples, notamment Unable to continue et Operation completed, reste en anglais puisque les blocs de code et de sortie ne sont pas modifiés. Le statut choisi indique à l’environnement appelant si l’opération a réussi :
#include <cstdlib>
#include <iostream>
#include <string_view>
int main(int argc, char* argv[]) {
if (argc > 1 && std::string_view(argv[1]) == "--fail") {
std::cerr << "Unable to continue" << '\n';
std::exit(EXIT_FAILURE);
}
std::cout << "Operation completed" << '\n';
return EXIT_SUCCESS;
}
Ce qui s’exécute lors d’une terminaison normale
Le nettoyage est sélectif. Les fonctions std::atexit enregistrées sont appelées, les objets à durée de stockage statique sont détruits et les flux C sont vidés puis fermés. Les objets automatiques de la fonction qui appelle std::exit ne sont pas détruits, car l’appel ne revient pas en traversant leurs portées. Par conséquent, si vous utilisez std::exit, ne comptez pas sur les destructeurs locaux pour libérer un fichier, un verrou ou une autre ressource ; effectuez d’abord le nettoyage ou retournez normalement en traversant la portée qui possède la ressource.
Un statut communique le résultat du programme, mais ne décrit pas à lui seul la cause de l’échec. Avant de terminer, affichez ou consignez un diagnostic utile, et documentez les éventuelles valeurs de statut propres à l’application pour ses appelants. Pour les conventions portables de réussite et d’échec, utilisez EXIT_SUCCESS et EXIT_FAILURE de <cstdlib>.
Enregistrer le nettoyage avec std::atexit
Enregistrez une fonction avec std::atexit si elle doit être appelée lors d’une terminaison normale via std::exit ou lors d’un retour de main. Les fonctions sont appelées dans l’ordre inverse de leur enregistrement. Elles doivent effectuer un nettoyage limité et éviter de dépendre des objets automatiques de la fonction qui a lancé la terminaison.
Cet exemple autonome enregistre deux fonctions de rappel avec des libellés distincts. Comme elles sont appelées dans l’ordre inverse de leur enregistrement, release_cache s’exécute avant close_log. Ces libellés, ainsi que le texte affiché par l’exemple, restent en anglais puisque les blocs de code et de sortie sont conservés à l’identique :
#include <cstdlib>
#include <iostream>
void close_log() {
std::cout << "close log" << '\n';
}
void release_cache() {
std::cout << "release cache" << '\n';
}
int main() {
std::atexit(close_log);
std::atexit(release_cache);
std::cout << "main work" << '\n';
return EXIT_SUCCESS;
}
main work
release cache
close log
Quand préférer un retour depuis main
Retourner depuis main est le choix habituel lorsque le travail normal est terminé ou qu’un résultat peut être transmis le long de la chaîne d’appels. L’entier retourné devient le statut du programme, et les objets automatiques locaux de main sont détruits au retour de la fonction. Les fonctions englobantes et les destructeurs peuvent ainsi effectuer leur nettoyage normal.
Utilisez std::exit lorsque le programme doit se terminer depuis une fonction plus profonde et qu’un retour normal ne permet pas de transmettre facilement cette décision. Avant de le faire, tenez compte des objets automatiques qui ne seront pas détruits. Pour les erreurs qui peuvent être traitées, retournez une valeur d’erreur ou propagez une exception jusqu’à un point de traitement approprié ; réservez la terminaison de tout le processus aux cas où il ne convient pas de poursuivre.