Java du Système.exit(0); vs C++ return 0;

Lorsque nous apprendre le C++ à l'école, notre professeur nous dira à écrire return 0; à la dernière ligne de code dans la fonction main et il est considéré comme une bonne pratique.

En Java, je me rends compte que certaines personnes écrit System.exit(0); à la dernière ligne de la méthode main.

Toutefois, en C++, si j'utilise exit(0); je être pénalisé par mon professeur, parce que (à l'école) pour la programmation procédurale, nous sommes attendus pour laisser le flux de programme jusqu'à la fin du main et de laisser le programme s'arrête naturellement.

Ma question: Est Java System.exit(0); similaire à C++de return 0; ? (Ou est-il semblable à C++exit(0))

Est-il une mauvaise pratique de l'utilisation System.exit(0) en java lorsqu'elle n'est pas (I. e.: l'écriture de la dernière ligne de la méthode main)?

  • C'est plutôt contextuel, comme une "vieille école" de développeur, j'ai appris qu'il n'y avait point d'entrée et un point de sortie (en parlant de fonctions et de méthodes), mais cela peut être vrai pour System.exit ainsi. Le problème avec l'utilisation de ce sein de votre code est le même que le fait d'avoir plusieurs return états dans vos fonctions/méthodes, ils sont faciles à manquer et peut faire comprendre le code plus difficile. Cela dit, il y a des exceptions à chaque règle et certains projets peuvent nécessiter votre mettre fin à l'exécution du programme de traitement...mais je serais toujours à la recherche de l'écart pour l'éviter...
  • Je n'ai jamais utilisé System.exit(0); à la dernière ligne de la méthode main.
  • Et bien comme le C++, l'un est ajouté, en silence.
  • Peut-être cette question permettra d'expliquer: stackoverflow.com/q/3715967/3651800
  • Je viens de le lien que vous avez collé.
  • alors vous devriez vous l'avez mentionné dans votre question et a déclaré qu'il n'a pas de clarifier les choses pour vous.
  • System.exit(0); en java est égal à exit(0); en C return; ou return 0; en java est égal à return; ou return 0; dans C. fermeture de la sortie de l'ensemble du processus, tandis que le rendement tout juste sorties de la sous-routine ou une fonction.

InformationsquelleAutor user3437460 | 2014-06-25
  1. 16

    De Java System.exit(0) est comme le C++de exit(0) dans ce

    • Il termine le processus
    • Il peut être appelé à partir de n'importe où dans le programme.

    Le dernier point en fait un “non structurées” contrôle des flux de construire que les types ont tendance à froncer les sourcils sur. (Dans ce cas, ils ont une bonne raison: Si une fonction signale un échec via une exception (ou à l'ancienne code de retour), il est possible que l'appelant afin de récupérer de l'erreur, mais exit brûle pont. Bien sûr, parfois, les erreurs ne doivent être traités comme des mortels.)

    En C++, return 0 est équivalent à exit(0) si c'est dans le main fonction. (Dans d'autres fonctions, ça ne veut rien dire de spécial.)

    Pertinentes différents entre C++ et Java ici est le type de retour de main.

    • En C++, main doit retourner int. Normalement, cela signifierait qu'il doit ont un return déclaration, mais le C++ standard fait main un cas particulier avec un implicite return 0; comme la fin si vous n'avez pas à écrire une.
    • En Java, main doit retourner void.

    En C++, il est courant d'écrire return états main, même si techniquement c'est redondant, pour la cohérence stylistique avec tous les autres non-void fonctions de votre programme.

    En Java, vous ne pouvez pas return le code de sortie de main parce que c'est un void fonction. Donc, si vous voulez spécifier explicitement un code de sortie, vous devez utiliser System.exit.

    Ce n'est pas mal à la fin de chaque Java main fonction avec System.exit(0), mais c'est juste pas idiomatiques de le faire, sauf si vous avez une construction comme

    public static void main(String[] args) {
   try {
       //... do the work
       System.exit(0);
   } catch (Throwable t) {
       //... report the error
       System.exit(1);
   }
}
    • Il est de mal à mettre fin à la main méthode avec un exit si votre application utilise des fils de démon pour plus que le thread principal de sa vie.
    • Alors, quelle est la bonne manière de définir le code de sortie en java? Rejoignez sur tous les non-fils de démon en premier et ensuite la sortie(1)?
    • Ne exit(0) mess avec RAII? Fichiers/sockets/etc. ouvert en principal peut pas vider leur sortie correctement.
    • Java n'a pas RAII. Fichiers/sockets/etc. doit être explicitement fermée. (Même si les versions les plus récentes de la langue ont un try-avec-des ressources en construction, semblable à C# using, qui font de ce un peu plus pratique.)
    • Je pense que je faisait référence à la c++ exit(0) dans la partie principale. Un exit(0) principaux peuvent empêcher les destructeurs des objets statiques de course, ce qui peut entraîner unflushed de fichiers, sockets, etc. .
    InformationsquelleAutor dan04
  2. 6

    Dans Le Système Java.exit(0),Système.exit(1),Système.exit(-1) est utilisé pour savoir si l'exécution du programme est allé de bon ou de mauvais. 0 est utilisé lors de l'exécution s'est bien passé. 1, -1, whatever != 0 quand une erreur s'est produite, vous pouvez utiliser des valeurs différentes pour les différents types d'erreurs.

    Vous pouvez aussi le dire comme ceci:

    0 signifie tout d'Accord

    1 signifie quelque chose que j'attend d'aller mal s'est mal passé

    -1 signifie quelque chose auquel je ne m'attendais pas a mal tourné

    La Java Doc dit:

    L'argument sert un code d'état; par convention, un statut différent de zéro
    ce code indique un arrêt anormal.

    Est Java du Système.exit(0); similaire à C++'s return 0; ?

    Oui ils ont tous les deux sont semblables.

    Est-il une mauvaise pratique de l'utilisation du Système.exit(0) en java, quand il est
    inutile

    Je ne dirais pas que c'est une mauvaise pratique, mais oui, vous devez être conscient de quand à l'utiliser et où l'utiliser. Vous pouvez l'utiliser pour lever une erreur pour un outil de ligne de commande via un code de sortie au lieu de lancer une exception. System.exit(0) met fin à la JVM de sorte que vous devez être très sûr de l'endroit où l'utilisation que.

    Un exemple pour que:

    try {  
    runTheWholeApplication();  
    System.exit(0);  //Signifying the normal end of your program
} catch (Throwable t) {  
    reportErrorSomehow(t);  
    System.exit(1);  //Signifying that there is an error
}
    • Je suppose qu'elle agit comme C++exit(0). Alors peut-être que nous devrions éviter de l'utiliser à moins que nous écrivons des programmes avec des fils..etc ?
    • Oui. C'est la même chose.
    • Sur les systèmes POSIX, le code de sortie est un entier 8 bits non signé. Vous peut return -1, mais il est interprété comme 255 (en raison de complément à deux).
    InformationsquelleAutor Rahul Tripathi
  3. 4

    Lorsque nous apprendre le C++ à l'école, notre professeur nous dira à écrire return 0; à la dernière ligne de code dans la fonction main et il est considéré comme une bonne pratique.

    C'est discutable. Il a également dit que return 0; est implicite à l'intérieur de main? Personnellement, je n'ai jamais écrit le redondante return 0; à l'intérieur de main, et je n'ai presque jamais le voir chez les autres les gens du code.

    InformationsquelleAutor fredoverflow
  4. 3

    Oui. Java est System.exit(0); est un analogue direct parce que le prototype Java main méthode est définie comme

    public static void main(String[] args) {
}

    De sorte qu'il ne peuvent littéralement pas return un int (même s'il peut tout simplement return;). En C++, vous pourriez exit(0); qui est aussi équivalent.

    • ...et return;
    • Édité. Oui. Vous pouvez simplement return.
    InformationsquelleAutor Elliott Frisch
  5. 3

    L'original système d'exploitation Unix beaucoup compté sur la ligne de commande à l'aide de scripts et de les combiner de nombreux petits programmes. Un code de retour d'un programme a été utilisé pour le contrôle de flux. Code de retour 0 signifie tout d'accord, non-zéro pour les erreurs.

    De sorte que le C int main(...) est un mapping direct, et return 0; à la fin appropriés. Sortie il y a peu comme lancer une exception, sans passer par un retour. Il désactive également l'appel de la principale à partir d'un autre programme.

    Dans Java public void main(...) cela a été simplifié, et 0 est implicite. System.exit(0); a la même mauvaise hypothèse qu'aucun autre programme appels main. Si, en général, void miroir de 99% d'utilisation, maintenant System.exit(...); est inévitable pour un non-zéro code d'erreur.

    Ce doit aussi être considéré comme un plus générale, la conception de la décision; C s'appuie fortement sur les codes de retour des fonctions, ce qui rend le contrôle des flux de difficile ou de commettre des erreurs, whereeas Java introduit l'utilisation d'Exceptions possible obligatoire de flux de contrôle, avec un librement chooseable attraper. Aujourd'hui, une alternative à System.exit(13) pourrait être throw new IllegalArgumentException("Unlucky");.

    • Donc, à votre avis, est-ce une mauvaise pratique de l'utilisation System.exit(0) de la dernière ligne de java principal?
    • Non ce n'est pas une mauvaise pratique. Je voudrais expliquer un tel scénario, lorsque vous écrivez un lot ou d'un script shell, chaque programme s'exécute le script a un code d'erreur sur la sortie. En règle générale, si le code d'erreur est égale à zéro, aucune action ne doit être prise, mais si le code d'erreur est non-nul, vous pouvez écrire une routine de traiter avec elle, même si elle ne quitte prématurément. Donc, dans ce cas, il n'est pas une mauvaise idée d'utiliser le Système.exit()
    • Oui, superflu et de faire plus de travail, comme x = x; ou return;. L'esprit, pour un programme qui utilise ces codes de retour, il pourrait être considéré comme de la documentation: un indice.
    • Merci pour la réponse, votre solution est plus en profondeur que le reste. + 1 from me
    • vous avez raison aussi; mais une JVM programme de sortie n'a normalement de retour 0, donc on n'a pas besoin de l'écrire explicitement, comme l'écrit return; à la fin d'une fonction void est un signe de l'incertitude du programmeur. Mais comme dit plus haut, il peut être le style, la liste de tous System.exit(...)s.
    InformationsquelleAutor Joop Eggen