web-dev-qa-db-fra.com

Comment créer un programme de sortie console C++?

Existe-t-il une ligne de code qui mettra fin au programme? 

Quelque chose comme sys.exit() de python?

c++exit
28
rectangletangle
#include <cstdlib>
...
exit( exit_code );
19
Benjamin Lindley

Pendant que vous pouvez appeler exit() (et qu’il faudra peut-être le faire si votre application rencontre une erreur fatale), le moyen le plus propre de quitter un programme est de revenir de main():

int main()
{
    // do whatever your program does

} // function returns and exits program

Lorsque vous appelez exit(), les objets à durée de stockage automatique (variables locales) ne sont pas détruits avant la fin du programme. Vous ne bénéficiez donc pas d'un nettoyage correct. Ces objets peuvent avoir besoin de nettoyer toutes les ressources qu'ils possèdent, de conserver les modifications d'état en attente, de terminer les threads en cours d'exécution ou d'effectuer d'autres actions pour que le programme se termine correctement.

26
James McNellis

Il existe plusieurs façons de provoquer la fermeture de votre programme. Laquelle est appropriée dépend de la raison pour laquelle vous voulez que votre programme se termine. La plupart du temps, cela devrait être en exécutant une instruction return dans votre fonction principale. Comme ci-dessous.

int main()
{
     f();
     return 0;
}

Comme d'autres l'ont identifié, cela permet à toutes vos variables de pile d'être correctement détruites afin d'être nettoyées correctement. C'est très important.

Si vous avez détecté une erreur au fond de votre code et que vous devez sortir, vous devriez lancer une exception pour revenir à la fonction principale. Comme ci-dessous.

struct stop_now_t { };
void f()
{
      // ...
      if (some_condition())
           throw stop_now_t();
      // ...
}

int main()
{
     try {
          f();
     } catch (stop_now_t& stop) {
          return 1;
     }
     return 0;
 }

Cela entraîne le déroulement de la pile et la destruction de toutes vos variables de la pile. Encore très important Notez qu'il est approprié d'indiquer un échec avec une valeur de retour non nulle.

Si, dans le cas peu probable, votre programme détecte une condition indiquant qu'il n'est plus sûr d'exécuter d'autres instructions, utilisez std :: abort (). Votre programme s’arrêtera brusquement sans traitement supplémentaire. std :: exit () est similaire mais peut appeler des gestionnaires atexit, ce qui peut être mauvais si votre programme est suffisamment bouché. 

7
Bowie Owens

Oui! exit() . C'est dans <cstdlib>.

4
Oliver Charlesworth

Autoriser le flux d'exécution à quitter main en renvoyer une valeur ou en permettant à l'exécution d'atteindre la fin de la fonction est le moyen par lequel un programme devrait se terminer, sauf dans des circonstances irrécupérables. Le renvoi d'une valeur est facultatif en C++, mais je préfère généralement renvoyer EXIT_SUCCESS trouvé dans cstdlib (une valeur spécifique à la plate-forme qui indique que le programme a été exécuté avec succès).

#include <cstdlib>

int main(int argc, char *argv[]) {
  ...
  return EXIT_SUCCESS;
}

Si, toutefois, votre programme atteint un état irrécupérable, il devrait lever une exception. Cependant, il est important de comprendre les conséquences. Il n'y a pas de meilleures pratiques largement acceptées pour décider de ce qui devrait ou ne devrait pas être une exception, mais il y a quelques règles générales que vous devez connaître.

Par exemple, lancer une exception depuis un destructeur est presque toujours une idée terrible, car l'objet en cours de destruction peut avoir été détruit car une exception a déjà été lancée. Si une deuxième exception est levée, terminate est appelé et votre programme s’arrêtera sans qu'aucun nettoyage supplémentaire n’ait été effectué. Vous pouvez utiliser uncaught_exception pour déterminer si c'est sûr, mais il est généralement préférable de ne jamais autoriser les exceptions à laisser un destructeur.

Bien qu’il soit généralement toujours possible pour les fonctions que vous appelez mais n’écrivez pas de lancer des exceptions (par exemple, new lancera std::bad_alloc s’il ne peut pas allouer suffisamment de mémoire), il est souvent difficile pour les programmeurs débutants de garder une trace ou même de tout des règles spéciales entourant les exceptions en C++. Pour cette raison, je recommande de ne les utiliser que dans des situations où votre programme ne dispose d'aucun moyen sensé de poursuivre l'exécution.

#include <stdexcept>
#include <cstdlib>
#include <iostream>

int foo(int i) {
  if (i != 5) {
    throw std::runtime_error("foo: i is not 5!");
  }
  return i * 2;
}

int main(int argc, char *argv[]) {
  try {
    foo(3);
  }
  catch (const std::exception &e) {
    std::cout << e.what() << std::endl;
    return EXIT_FAILURE;
  }
  return EXIT_SUCCESS;
}

exit est une retenue de C et peut avoir pour conséquence que des objets avec stockage automatique ne soient pas nettoyés correctement. abort et terminate amène le programme à se suicider et ne va certainement pas nettoyer les ressources.

Quoi que vous fassiez, n'utilisez pas des exceptions, exit ou abort/terminate comme une béquille pour vous aider à écrire un programme correctement structuré. Enregistrez-les pour des situations exceptionnelles.

3
Sydius

si vous êtes dans la principale, vous pouvez faire: 

return 0;

ou 

exit(exit_code);

Le code de sortie dépend de la sémantique de votre code. 1 est l'erreur 0 e une sortie normale.

Dans une autre fonction de votre programme: 

exit(exit_code)

quittera le programme. 

2
Corgan

Dans main (), il y a aussi:

return 0;
0
Moberg
#include <cstdlib>
...
/*wherever you want it to end, e.g. in an if-statement:*/
if (T == 0)
{
exit(0);
}
0
Shadow