Dois-je renvoyer EXIT_SUCCESS ou 0 depuis main ()?
C'est une question simple, mais je continue à voir des réponses contradictoires: la routine principale d'un programme C++ doit-elle renvoyer 0 Ou EXIT_SUCCESS?
#include <cstdlib>
int main(){return EXIT_SUCCESS;}
ou
int main(){return 0;}
Sont-ils exactement la même chose? Doit-on utiliser EXIT_SUCCESS Uniquement avec exit()?
Je pensais que EXIT_SUCCESS Serait une meilleure option car un autre logiciel peut vouloir considérer zéro comme un échec, mais j'ai aussi entendu dire que si vous renvoyez 0, Le compilateur est capable de le changer en une valeur différente. en tous cas.
EXIT_FAILURE, Soit dans une instruction return dans main, soit en tant qu'argument de exit(), est le seul moyen portable d'indiquer un échec dans un programme C ou C++. exit(1) peut par exemple signaler la réussite d'une terminaison sur VMS.
Si vous utilisez EXIT_FAILURE Lorsque votre programme échoue, vous pouvez également utiliser EXIT_SUCCESS Lorsqu'il réussit, pour des raisons de symétrie.
D'un autre côté, si le programme ne signale jamais d'échec, vous pouvez utiliser 0 Ou EXIT_SUCCESS. Les deux sont garantis par la norme pour signaler leur réussite. (Il est à peine possible que EXIT_SUCCESS Puisse avoir une valeur autre que 0, mais égale à 0 pour chaque implémentation dont j'ai entendu parler.)
L'utilisation de 0 Présente le petit avantage de ne pas avoir besoin de #include <stdlib.h> En C ou de #include <cstdlib> En C++ (si vous utilisez plutôt une instruction return que d'appeler exit()) - mais pour un programme de toute taille significative, vous allez inclure stdlib directement ou indirectement de toute façon.
D'ailleurs, en C à partir de 1999 et dans toutes les versions de C++, atteindre la fin de main() fait de toute façon un return 0; Implicite; vous n'aurez donc peut-être pas besoin d'utiliser 0 Ou EXIT_SUCCESS Explicitement. (Mais au moins en C, je considère qu'un return 0; Explicite est un meilleur style.)
(Quelqu'un a posé des questions sur OpenVMS. Je ne l'ai pas utilisé depuis longtemps, mais, si je me souviens bien, les valeurs d'état impaires indiquent généralement le succès, alors que les valeurs paires désignent l'échec. L'implémentation C mappe 0 À 1 , afin que return 0; indique que la terminaison est réussie. Les autres valeurs sont transmises sans modification, de sorte que return 1; indique également la terminaison réussie. EXIT_FAILURE aurait une valeur paire non nulle.)
Ce n'est pas important. Les deux sont les mêmes.
Citations standard C++:
Si la valeur de status est zéro ou EXIT_SUCCESS, une forme de la terminaison avec statut définie par l'implémentation est renvoyée.
C'est une histoire sans fin qui reflète les limites (un mythe) de "l'interopérabilité et de la potabilité avant tout".
Ce que le programme doit retourner pour indiquer "succès" doit être défini par la personne qui reçoit la valeur (le système d'exploitation ou le processus qui a appelé le programme) et non par une spécification de langage.
Mais les programmeurs aiment écrire du code "de manière portable" et inventent donc leur propre modèle pour le concept de "système d'exploitation" définissant les valeurs symboliques à renvoyer.
Maintenant, dans un scénario plusieurs-à-plusieurs (où plusieurs langues servent à écrire des programmes sur plusieurs systèmes), la correspondance entre la convention de langue pour "succès" et celle du système d'exploitation (que personne ne peut accorder d'être toujours identique) devrait être traité par la mise en œuvre spécifique d'une bibliothèque pour une plate-forme cible spécifique.
Malheureusement, ces concepts n'étaient pas aussi clairs au moment de déployer le langage C (principalement pour écrire le noyau UNIX), et les gigagrammes de livres où écrit en indiquant "return 0 signifie success", comme c'était le cas sous OS ce moment-là ayant un compilateur C.
À partir de ce moment, aucune normalisation claire n’a été faite sur la manière dont une telle correspondance devrait être traitée. C et C++ ont leur propre définition de "valeurs de retour" mais personne n'accorde une traduction correcte du système d'exploitation (ou mieux: aucune documentation du compilateur ne dit rien à ce sujet). 0 signifie succès si cela est vrai pour UNIX - LINUX et - pour des raisons indépendantes - également pour Windows, et cela couvre 90% des "ordinateurs grand public" existants, qui - dans la plupart des cas - ne tient pas compte de la valeur de retour (nous pouvons donc discuter pendant des décennies, mais personne ne le remarquera jamais!)
Dans ce scénario, avant de prendre une décision, posez les questions suivantes: - Suis-je intéressé à communiquer quelque chose à mon interlocuteur à propos de mon existant? (Si je retourne toujours 0 ... il n'y a aucune idée derrière tout) - Mon correspondant at-il des conventions concernant cette communication? (Notez qu'une seule valeur n'est pas une convention: cela n'autorise aucune représentation d'informations)
Si les deux réponses sont non, la bonne solution est probablement de ne pas écrire la déclaration de retour principale du tout. (Et laissez le compilateur décider, par rapport à la cible qui travaille).
Si aucune convention n'est en place 0 = le succès satisfait la plupart des situations (et l'utilisation de symboles peut être problématique si elle introduit une convention).
Si des conventions sont en place, veillez à utiliser des constantes symboliques qui sont cohérentes avec elles (et assurez-vous de la cohérence des conventions, et non de la cohérence des valeurs, entre les plates-formes).
0 est, par définition, un nombre magique. EXIT_SUCCESS est presque universellement égal à 0, heureusement. Alors pourquoi ne pas simplement revenir/quitter 0?
exit (EXIT_SUCCESS); est très clair dans sa signification.
sortie (0); d'autre part, est contre-intuitif à certains égards. Quelqu'un qui ne connaît pas bien le comportement de Shell pourrait supposer que 0 == faux == mauvais, comme pour toute autre utilisation de 0 en C. Mais non - dans ce cas particulier, 0 == succès == bien. Pour les développeurs les plus expérimentés, cela ne posera pas de problème. Mais pourquoi faire trébucher le nouveau sans aucune raison?
tl; dr - s'il existe une constante définie pour votre nombre magique, il n'y a presque jamais de raison de ne pas utiliser la constante au départ. C'est plus facile à rechercher, souvent plus clair, etc. et cela ne vous coûte rien.
Une fois que vous commencez à écrire du code pouvant renvoyer une myriade d’états de sortie, vous démarrez #define 'ing tous. Dans ce cas EXIT_SUCCESS est logique dans le contexte où il ne s'agit pas d'un " nombre magique ". Cela rend votre code plus lisible car chaque autre code de sortie sera EXIT_SOMETHING. Si vous écrivez simplement un programme qui reviendra une fois terminé, return 0 est valide et probablement même plus propre car cela suggère qu'il n'y a pas de structure de code retour sophistiquée.
Ce que vous retournez d’un programme n’est qu’une convention.
Non, je ne vois aucune circonstance où "EXIT_SUCCESS" ne serait pas soit "0".
Personnellement, je recommanderais "0".
A MON HUMBLE AVIS...