Comment puis-je faire une console C++ la sortie du programme?

#include <cstdlib>
...
exit( exit_code );

Il y a plusieurs façons à cause de votre programme de résilier. Celle qui est appropriée dépend de pourquoi vous voulez que votre programme à la fin. La grande majorité du temps, il devrait être par l'exécution d'une instruction de retour dans votre fonction principale. Comme dans l'exemple suivant.

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

Comme d'autres l'ont identifié cela permet à tous de votre pile de variables pour être correctement détruits de manière à nettoyer correctement. C'est très important.

Si vous avez détecté une erreur quelque part au fond de votre code et que vous devez sortir, vous devriez jeter une exception pour revenir à la fonction principale. Comme dans l'exemple suivant.

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 provoque de la pile pour être dénoué une toutes vos variables de pile à être détruits. Encore très important. Notez qu'il est approprié pour indiquer l'échec avec un zéro de la valeur de retour.

Si dans le cas peu probable que votre programme détecte une condition qui indique qu'il n'est plus sûr d'exécuter plusieurs instructions, alors vous devriez utiliser std::abort(). Cela permettra de porter votre programme à un arrêt brutal sans traitement supplémentaire. std::exit() est similaire, mais peut faire appel atexit gestionnaires qui pourrait être mauvais si votre programme est suffisamment complètement foireuse.

Permettant l'exécution de flux de quitter main par retour d'une valeur ou d'autoriser l'exécution d'atteindre la fin de la fonction est la façon dont le programme devrait mettre fin à l'exception en vertu de l'irrécupérable circonstances. De retour d'une valeur est facultative en C++, mais en général, je préfère retourner EXIT_SUCCESS trouvé dans cstdlib (une plate-forme spécifique qui indique que le programme s'est exécuté avec succès).

#include <cstdlib>

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

Si, cependant, votre programme atteint un état irrécupérable, il doit lever une exception. Il est important de comprendre les implications de cela, cependant. Il n'y a pas largement accepté par les meilleures pratiques pour décider de ce qui doit ou ne doit pas être une exception, mais il ya quelques règles générales que vous devez être conscient de.

Par exemple, lancer une exception à partir d'un destructeur est presque toujours une mauvaise idée parce que l'objet est détruit pourrait avoir été détruite à cause d'une exception avait déjà été levée. Si une deuxième exception est levée, terminate est appelé et que votre programme s'arrête sans plus de nettoyage ait été effectuée. Vous peut utilisation uncaught_exception pour déterminer si c'est sûr, mais il est généralement préférable de ne jamais autoriser des exceptions à laisser un destructeur.

Alors qu'il est toujours possible pour les fonctions en vous appeler, mais n'a pas écrit de lever des exceptions (par exemple, new va jeter std::bad_alloc si il ne peut pas allouer suffisamment de mémoire), il est souvent difficile pour les débutants que pour les programmeurs de garder une trace de, ni même de connaître toutes les règles entourant les exceptions en C++. Pour cette raison, je recommande uniquement les utiliser dans des situations où il n'y a pas de bon sens pour votre programme pour continuer 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 un hold-dessus de C et peut entraîner des objets avec stockage automatique pour ne pas être nettoyés correctement. abort et terminate provoque efficacement le programme à commettre le suicide, et certainement ne pas nettoyer les ressources.

Quoi que vous fassiez, ne pas utiliser les exceptions, exit, ou abort/terminate comme une béquille pour obtenir autour de l'écriture adéquate d'un programme structuré. Les enregistrer pour les situations exceptionnelles.

Dans main(), il y a aussi:

return 0;

else if(Decision >= 3)
    {
exit(0);
    }

assez simple..

exit ( 0 );
}//fin de la fonction

Assurez-vous que il y a un espace sur les deux côtés de l'0. Sans les espaces, le programme ne s'arrêtera pas.