Que doit retourner main () en C et C ++?

Quelle est la manière correcte (la plus efficace) de définir la main()fonction en C et C ++ - int main()ou void main()- et pourquoi? Si int main()alors return 1ou return 0?

Il existe de nombreux doublons de cette question, notamment:

• Quelles sont les signatures valides pour la main()fonction de C ?
• Le type de main()fonction de retour
• Différence entre void main()et int main()?
• main()signature de C ++
• Quelle est la bonne déclaration de main()? - Pour C ++, avec une très bonne réponse en effet.
• Styles de main()fonctions en C
• Retourne le type de main()méthode en C
• int main()vs void main()en C

En relation:

• C ++ - int main(int argc, char **argv)
• C ++ - int main(int argc, char *argv[])
• Est- char *envp[]ce un troisième argument pour main()portable?
• La int main()fonction doit-elle renvoyer une valeur dans tous les compilateurs?
• Pourquoi le type de la main()fonction en C et C ++ est-il laissé à l'utilisateur à définir?
• Pourquoi int main(){}compile-t-on?
• Définitions légales de main()C ++ 14?

La valeur de retour pour mainindique comment le programme s'est arrêté. La sortie normale est représentée par une valeur de retour 0 de main. Une sortie anormale est signalée par un retour non nul, mais il n'y a pas de norme pour la façon dont les codes non nuls sont interprétés. Comme indiqué par d'autres, void main()est interdit par la norme C ++ et ne doit pas être utilisé. Les mainsignatures C ++ valides sont:

int main()

et

int main(int argc, char* argv[])

ce qui équivaut à

int main(int argc, char** argv)

Il convient également de noter qu'en C ++, il int main()peut être laissé sans instruction de retour, auquel cas il renvoie par défaut 0. Cela est également vrai avec un programme C99. Que ce return 0;soit omis ou non est sujet à débat. La plage de signatures principales valides du programme C est beaucoup plus grande.

L'efficacité n'est pas un problème avec la mainfonction. Il ne peut être entré et laissé qu'une seule fois (marquant le début et la fin du programme) selon la norme C ++. Pour C, la rentrée main()est autorisée, mais doit être évitée.

La réponse acceptée semble être ciblée pour C ++, j'ai donc pensé ajouter une réponse qui concerne C, et cela diffère de plusieurs façons.

ISO / CEI 9899: 1989 (C90):

main() doit être déclaré comme suit:

int main(void)
int main(int argc, char **argv)

Ou équivalent. Par exemple, int main(int argc, char *argv[])est équivalent au second. En outre, le inttype de retour peut être omis car il s'agit d'une valeur par défaut.

Si une implémentation le permet, elle main()peut être déclarée par d'autres moyens, mais cela rend l'implémentation du programme définie et non plus strictement conforme.

La norme définit 3 valeurs pour le retour qui sont strictement conformes (c'est-à-dire, ne reposent pas sur un comportement défini par l'implémentation): 0et EXIT_SUCCESSpour une terminaison réussie et EXIT_FAILUREpour une terminaison infructueuse. Toutes les autres valeurs sont non standard et définies par l'implémentation. main()doit avoir une returndéclaration explicite à la fin pour éviter un comportement indéfini.

Enfin, il n'y a rien de mal du point de vue des normes à appeler à main()partir d'un programme.

ISO / CEI 9899: 1999 (C99):

Pour C99, tout est le même que ci-dessus sauf:

• Le inttype de retour ne doit pas être omis.
• Vous pouvez omettre la déclaration de retour de main(). Si vous le faites et que vous avez main()terminé, il y a un implicite return 0.

Standard C - Environnement hébergé

Pour un environnement hébergé (c'est le normal), la norme C11 (ISO / IEC 9899: 2011) dit:

5.1.2.2.1 Démarrage du programme

La fonction appelée au démarrage du programme est nommée main . L'implémentation ne déclare aucun prototype pour cette fonction. Il doit être défini avec un type de retour intet sans paramètres:

int main(void) { /* ... */ }

ou avec deux paramètres (appelés ici argcetargv , bien que tous les noms puissent être utilisés, car ils sont locaux à la fonction dans laquelle ils sont déclarés):

int main(int argc, char *argv[]) { /* ... */ }

ou équivalent;¹⁰⁾ ou d'une autre manière définie par la mise en œuvre.

S'ils sont déclarés, les paramètres de la fonction principale doivent respecter les contraintes suivantes:

• La valeur de argc doit être non négative.
• argv[argc] doit être un pointeur nul.
• Si la valeur de argcest supérieure à zéro, les membres du tableau argv[0]via argv[argc-1] inclus doivent contenir des pointeurs vers des chaînes, qui reçoivent des valeurs définies par l'implémentation par l'environnement hôte avant le démarrage du programme. L'intention est de fournir au programme des informations déterminées avant le démarrage du programme depuis un autre endroit de l'environnement hébergé. Si l'environnement hôte n'est pas capable de fournir des chaînes avec des lettres en majuscules et en minuscules, la mise en œuvre doit garantir que les chaînes sont reçues en minuscules.
• Si la valeur de argcest supérieure à zéro, la chaîne pointée par argv[0] représente le nom du programme; argv[0][0]doit être le caractère nul si le nom du programme n'est pas disponible dans l'environnement hôte. Si la valeur de argcest supérieure à un, les chaînes pointées par à argv[1]travers argv[argc-1] représentent les paramètres du programme.
• Les paramètres argcet argvles chaînes pointés par le argvtableau doivent être modifiables par le programme et conserver leurs dernières valeurs stockées entre le démarrage du programme et la fin du programme.

¹⁰⁾ Ainsi, intpeut être remplacé par un nom typedef défini comme int, ou le type de argvpeut être écrit comme char **argv, et ainsi de suite.

Fin du programme en C99 ou C11

La valeur renvoyée par main()est transmise à «l'environnement» d'une manière définie par l'implémentation.

5.1.2.2.3 Fin du programme

1 Si le type de retour de la mainfonction est compatible avec un type int, un retour de l'appel initial à la mainfonction équivaut à appeler la exitfonction avec la valeur renvoyée par la mainfonction comme argument; ¹¹⁾ atteindre la }fin de la mainfonction renvoie une valeur de 0. Si le type de retour n'est pas compatible avec int, l'état de terminaison renvoyé à l'environnement hôte n'est pas spécifié.

¹¹⁾ Conformément au 6.2.4, les durées de vie des objets avec durée de stockage automatique déclarée en main seront terminées dans le premier cas, même si elles ne le seraient pas dans le second.

Notez que 0c'est obligatoire comme «succès». Vous pouvez utiliser EXIT_FAILUREet à EXIT_SUCCESSpartir de <stdlib.h>si vous préférez, mais 0 est bien établi, ainsi que 1. Voir aussi Codes de sortie supérieurs à 255 - possible? .

Dans C89 (et donc dans Microsoft C), il n'y a aucune déclaration sur ce qui se passe si la main()fonction retourne mais ne spécifie pas de valeur de retour; il conduit donc à un comportement indéfini.

7.22.4.4 La exitfonction

¶5 Enfin, le contrôle est retourné à l'environnement hôte. Si la valeur de statusest zéro ou EXIT_SUCCESS, une forme définie par l'implémentation de la terminaison réussie du statut est renvoyée. Si la valeur de statusest EXIT_FAILURE, une forme définie par l'implémentation de la terminaison d'échec d' état est renvoyée. Sinon, le statut renvoyé est défini par l'implémentation.

Standard C ++ - Environnement hébergé

La norme C ++ 11 (ISO / IEC 14882: 2011) dit:

3.6.1 Fonction principale [basic.start.main]

¶1 Un programme doit contenir une fonction globale appelée main, qui est le début désigné du programme. [...]

¶2 Une implémentation ne doit pas prédéfinir la fonction principale. Cette fonction ne doit pas être surchargée. Il doit avoir un type de retour de type int, mais sinon son type est défini par l'implémentation. Toutes les implémentations doivent permettre les deux définitions suivantes de main:

int main() { /* ... */ }

et

int main(int argc, char* argv[]) { /* ... */ }

Dans cette dernière forme argcdoit être le nombre d'arguments transmis au programme à partir de l'environnement dans lequel le programme est exécuté. Si argcest différent de zéro, ces arguments doivent être fournis par le argv[0] biais argv[argc-1]de pointeurs vers les caractères initiaux des chaînes multioctets à terminaison nulle (NTMBS) (17.5.2.1.4.2) et argv[0]doivent être le pointeur sur le caractère initial d'un NTMBS qui représente le nom utilisé pour appeler le programme ou "". La valeur de argcdoit être non négative. La valeur de argv[argc] doit être 0. [Remarque: Il est recommandé d'ajouter tout autre paramètre (facultatif) après argv. —Fin note]

¶3 La fonction mainne doit pas être utilisée dans un programme. La liaison (3.5) de mainest définie par l'implémentation. [...]

¶5 Une instruction return dans main a pour effet de quitter la fonction main (détruire tous les objets avec une durée de stockage automatique) et d'appeler std::exitavec la valeur de retour comme argument. Si le contrôle atteint la fin de main sans rencontrer de déclaration de retour, l'effet est celui de l'exécution

return 0;

Le standard C ++ dit explicitement "Il [la fonction principale] doit avoir un type de retour de type int, mais sinon son type est défini par l'implémentation", et requiert les deux mêmes signatures que le standard C pour être pris en charge en option. Ainsi, un 'void main ()' n'est directement pas autorisé par la norme C ++, bien qu'il ne puisse rien faire pour arrêter une implémentation non standard autorisant des alternatives. Notez que C ++ interdit à l'utilisateur d'appeler main(mais pas la norme C).

Il y a un paragraphe du §18.5 Début et fin dans la norme C ++ 11 qui est identique au paragraphe du §7.22.4.4 La exitfonction dans la norme C11 (citée ci-dessus), à l'exception d'une note de bas de page (qui documente simplement cela EXIT_SUCCESSet qui EXIT_FAILUREest définie dans <cstdlib>).

Norme C - Extension commune

Classiquement, les systèmes Unix prennent en charge une troisième variante:

int main(int argc, char **argv, char **envp) { ... }

Le troisième argument est une liste de pointeurs vers des chaînes terminée par un caractère nul, chacune étant une variable d'environnement qui a un nom, un signe égal et une valeur (éventuellement vide). Si vous ne l'utilisez pas, vous pouvez toujours accéder à l'environnement via ' extern char **environ;'. Cette variable globale est unique parmi celles de POSIX en ce qu'elle n'a pas d'en-tête qui la déclare.

Ceci est reconnu par la norme C comme une extension commune, documentée à l'annexe J:

J.5.1 Arguments d'environnement

¶1 Dans un environnement hébergé, la fonction principale reçoit un troisième argument,, char *envp[]qui pointe vers un tableau de pointeurs à terminaison nulle char, chacun pointant vers une chaîne qui fournit des informations sur l'environnement pour cette exécution du programme (5.1. 2.2.1).

Microsoft C

Le compilateur Microsoft VS 2010 est intéressant. Le site Web dit:

La syntaxe de déclaration de main est

 int main();

ou, éventuellement,

int main(int argc, char *argv[], char *envp[]);

Alternativement, les fonctions mainet wmainpeuvent être déclarées comme retournant void(pas de valeur de retour). Si vous déclarez mainou wmainque vous retournez null, vous ne pouvez pas renvoyer un code de sortie au processus parent ou au système d'exploitation à l'aide d'une instruction return. Pour renvoyer un code de sortie lorsque mainou wmainest déclaré en tant que void, vous devez utiliser la exitfonction.

Il n'est pas clair pour moi ce qui se passe (quel code de sortie est retourné au parent ou au système d'exploitation) lorsqu'un programme se void main()ferme - et le site Web de MS est également silencieux.

Fait intéressant, MS ne prescrit pas la version à deux arguments main()requise par les normes C et C ++. Il ne prescrit qu'une forme à trois arguments où se trouve le troisième argument char **envp, un pointeur vers une liste de variables d'environnement.

La page Microsoft répertorie également quelques autres alternatives - wmain()qui prennent des chaînes de caractères larges, et quelques autres.

La version Microsoft Visual Studio 2005 de cette page ne figure pas void main()comme alternative. Les versions à partir de Microsoft Visual Studio 2008 le font.

Norme C - Environnement autonome

Comme indiqué précédemment, les exigences ci-dessus s'appliquent aux environnements hébergés. Si vous travaillez avec un environnement autonome (qui est l'alternative à un environnement hébergé), la norme a beaucoup moins à dire. Pour un environnement autonome, la fonction appelée au démarrage du programme n'a pas besoin d'être appelée mainet il n'y a aucune contrainte sur son type de retour. La norme dit:

5.1.2 Environnements d'exécution

Deux environnements d'exécution sont définis: autonome et hébergé. Dans les deux cas, le démarrage du programme se produit lorsqu'une fonction C désignée est appelée par l'environnement d'exécution. Tous les objets avec une durée de stockage statique doivent être initialisés (définis sur leurs valeurs initiales) avant le démarrage du programme. La manière et le moment d'une telle initialisation ne sont par ailleurs pas spécifiés. La fin du programme renvoie le contrôle à l'environnement d'exécution.

5.1.2.1 Environnement autonome

Dans un environnement autonome (dans lequel l'exécution du programme C peut avoir lieu sans aucun avantage d'un système d'exploitation), le nom et le type de la fonction appelée au démarrage du programme sont définis par l'implémentation. Toutes les installations de bibliothèque disponibles pour un programme indépendant, autres que l'ensemble minimal requis par l'article 4, sont définies par l'implémentation.

L'effet de l'arrêt du programme dans un environnement autonome est défini par l'implémentation.

Le renvoi à l'article 4 Conformité se réfère à ceci:

¶5 Un programme strictement conforme doit utiliser uniquement les caractéristiques du langage et de la bibliothèque spécifiés dans la présente Norme internationale. ³⁾ Il ne doit pas produire de sortie dépendante d'un comportement non spécifié, non défini ou défini par l'implémentation, et ne doit pas dépasser une limite d'implémentation minimale.

¶6 Les deux formes d'implémentation conforme sont hébergées et autonomes . Une implémentation hébergée conforme doit accepter tout programme strictement conforme. Une mise en œuvre conforme autoportant accepte tout programme conforme strictement dans lequel l'utilisation des fonctionnalités spécifiées dans la clause bibliothèque (article 7) se limite au contenu des en- têtes standards <float.h>, <iso646.h>, <limits.h>, <stdalign.h>, <stdarg.h>, <stdbool.h>, <stddef.h>, <stdint.h>et <stdnoreturn.h>. Une implémentation conforme peut avoir des extensions (y compris des fonctions de bibliothèque supplémentaires), à condition qu'elles ne modifient pas le comportement d'un programme strictement conforme. ⁴⁾

¶7 Un programme conforme est celui qui est acceptable pour une implémentation conforme. ⁵⁾

³⁾ Un programme strictement conforme peut utiliser des fonctionnalités conditionnelles (voir 6.10.8.3) à condition que l'utilisation soit protégée par une directive de prétraitement d'inclusion conditionnelle appropriée utilisant la macro associée. Par exemple:

#ifdef __STDC_IEC_559__ /* FE_UPWARD defined */
    /* ... */
    fesetround(FE_UPWARD);
    /* ... */
#endif

⁴⁾ Cela implique qu'une implémentation conforme ne réserve aucun identifiant autre que ceux explicitement réservés dans la présente Norme internationale.

^{5) Les} programmes strictement conformes sont destinés à être portatifs au maximum parmi les implémentations conformes. Les programmes conformes peuvent dépendre de fonctionnalités non portables d'une implémentation conforme.

Il est à noter que le seul en-tête requis d'un environnement autonome qui définit réellement toutes les fonctions est <stdarg.h>(et même celles-ci peuvent être - et sont souvent - simplement des macros).

Standard C ++ - Environnement autonome

Tout comme la norme C reconnaît à la fois l'environnement hébergé et autonome, la norme C ++ aussi. (Citations de l'ISO / CEI 14882: 2011.)

1.4 Conformité de l'implémentation [intro.compliance]

¶7 Deux types d'implémentations sont définis: une implémentation hébergée et une implémentation autonome . Pour une implémentation hébergée, la présente Norme internationale définit l'ensemble des bibliothèques disponibles. Une implémentation autonome est une implémentation dans laquelle l'exécution peut avoir lieu sans l'avantage d'un système d'exploitation, et possède un ensemble de bibliothèques défini par l'implémentation qui inclut certaines bibliothèques prenant en charge les langues (17.6.1.3).

¶8 Une implémentation conforme peut avoir des extensions (y compris des fonctions de bibliothèque supplémentaires), à condition qu'elles ne modifient pas le comportement d'un programme bien formé. Des implémentations sont nécessaires pour diagnostiquer les programmes qui utilisent de telles extensions mal formées conformément à la présente Norme internationale. Cela fait, cependant, ils peuvent compiler et exécuter de tels programmes.

¶9 Chaque implémentation doit comprendre une documentation qui identifie toutes les constructions à prise en charge conditionnelle qu'elle ne prend pas en charge et définit toutes les caractéristiques spécifiques aux paramètres régionaux. ³

³⁾ Cette documentation définit également le comportement défini par l'implémentation; voir 1.9.

17.6.1.3 Implémentations autonomes [conformité]

Deux types d'implémentations sont définis: hébergé et autonome (1.4). Pour une implémentation hébergée, la présente Norme internationale décrit l'ensemble des en-têtes disponibles.

Une implémentation autonome possède un ensemble d'en-têtes défini par l'implémentation. Cet ensemble doit comprendre au moins les en-têtes indiqués dans le tableau 16.

La version fournie de l' en- tête <cstdlib>doit déclarer au moins les fonctions abort, atexit, at_quick_exit, exitet quick_exit(18,5). Les autres en-têtes répertoriés dans ce tableau doivent répondre aux mêmes exigences que pour une implémentation hébergée.

Tableau 16 - En-têtes C ++ pour les implémentations autonomes

Subclause                           Header(s)
                                    <ciso646>
18.2  Types                         <cstddef>
18.3  Implementation properties     <cfloat> <limits> <climits>
18.4  Integer types                 <cstdint>
18.5  Start and termination         <cstdlib>
18.6  Dynamic memory management     <new>
18.7  Type identification           <typeinfo>
18.8  Exception handling            <exception>
18.9  Initializer lists             <initializer_list>
18.10 Other runtime support         <cstdalign> <cstdarg> <cstdbool>
20.9  Type traits                   <type_traits>
29    Atomics                       <atomic>

Qu'en est-il de l'utilisation int main()en C?

La norme §5.1.2.2.1 de la norme C11 montre la notation préférée -  int main(void)- mais il y a aussi deux exemples dans la norme qui montrent int main(): §6.5.3.4 ¶8 et §6.7.6.3 ¶20 . Maintenant, il est important de noter que les exemples ne sont pas «normatifs»; ils ne sont qu'illustratifs. S'il y a des bogues dans les exemples, ils n'affectent pas directement le texte principal de la norme. Cela dit, ils sont fortement indicatifs du comportement attendu, donc si la norme inclut int main()dans un exemple, cela suggère que ce int main()n'est pas interdit, même si ce n'est pas la notation préférée.

6.5.3.4 Les opérateurs sizeofet_Alignof

…

¶8 EXEMPLE 3 Dans cet exemple, la taille d'un tableau de longueur variable est calculée et renvoyée par une fonction:

#include <stddef.h>

size_t fsize3(int n)
{
    char b[n+3]; // variable length array
    return sizeof b; // execution time sizeof
}
int main()
{
    size_t size;
    size = fsize3(10); // fsize3 returns 13
    return 0;
}

Je crois que cela main()devrait revenir soit EXIT_SUCCESSou EXIT_FAILURE. Ils sont définis dansstdlib.h

Notez que les normes C et C ++ définissent deux types d'implémentations: autonomes et hébergées.

• Environnement hébergé C90

  Formulaires autorisés ¹ :

  int main (void)
  int main (int argc, char *argv[])
  
  main (void)
  main (int argc, char *argv[])
  /*... etc, similar forms with implicit int */

  Commentaires:

  Les deux premiers sont explicitement indiqués comme les formes autorisées, les autres sont implicitement autorisés car C90 a autorisé "implicit int" pour le type de retour et les paramètres de fonction. Aucun autre formulaire n'est autorisé.

• Environnement autoportant C90

  Toute forme ou nom de principal est autorisé ² .

• Environnement hébergé C99

  Formulaires autorisés ³ :

  int main (void)
  int main (int argc, char *argv[])
  /* or in some other implementation-defined manner. */

  Commentaires:

  C99 a supprimé "implicit int" et main()n'est donc plus valide.

  Une phrase étrange et ambiguë "ou d'une autre manière définie par la mise en œuvre" a été introduite. Cela peut être interprété comme «les paramètres int main()peuvent varier» ou comme «principal peut avoir n'importe quelle forme définie par l'implémentation».

  Certains compilateurs ont choisi d'interpréter la norme de cette dernière manière. On peut sans doute affirmer qu'ils ne sont pas strictement conformes en citant la norme en elle-même, car elle est ambiguë.

  Cependant, autoriser des formes complètement sauvages main()n'était probablement pas (?) L'intention de cette nouvelle phrase. La justification C99 (non normative) implique que la phrase se réfère à des paramètres supplémentaires à int main ⁴ .

  Pourtant, la section relative à l'arrêt du programme d'environnement hébergé continue de discuter du cas où main ne retourne pas int ⁵ . Bien que cette section ne soit pas normative sur la façon dont main doit être déclarée, elle implique certainement que main pourrait être déclarée de manière complètement définie par l'implémentation, même sur les systèmes hébergés.

• Environnement autonome C99

  Toute forme ou nom de principal est autorisé ⁶ .

• Environnement hébergé C11

  Formulaires autorisés ⁷ :

  int main (void)
  int main (int argc, char *argv[])
  /* or in some other implementation-defined manner. */

• Environnement autonome C11

  Toute forme ou nom de principal est autorisé ⁸ .

Notez que int main()n'a jamais été répertorié comme un formulaire valide pour toute implémentation hébergée de C dans l'une des versions ci-dessus. En C, contrairement à C ++, ()et (void)ont des significations différentes. Le premier est une fonction obsolète qui peut être supprimée de la langue. Voir les futures orientations linguistiques du C11:

6.11.6 Déclarateurs de fonctions

L'utilisation de déclarateurs de fonctions avec des parenthèses vides (et non des déclarants de type paramètre de type prototype) est une fonction obsolète.

• Environnement hébergé C ++ 03

  Formulaires autorisés ⁹ :

  int main ()
  int main (int argc, char *argv[])

  Commentaires:

  Notez la parenthèse vide dans le premier formulaire. C ++ et C sont différents dans ce cas, car en C ++, cela signifie que la fonction ne prend aucun paramètre. Mais en C, cela signifie qu'il peut prendre n'importe quel paramètre.

• Environnement autonome C ++ 03

  Le nom de la fonction appelée au démarrage est défini par l'implémentation. S'il est nommé, main()il doit suivre les formulaires indiqués ¹⁰ :

  // implementation-defined name, or 
  int main ()
  int main (int argc, char *argv[])

• Environnement hébergé C ++ 11

  Formulaires autorisés ¹¹ :

  int main ()
  int main (int argc, char *argv[])

  Commentaires:

  Le texte de la norme a été modifié, mais il a la même signification.

• Environnement autonome C ++ 11

  Le nom de la fonction appelée au démarrage est défini par l'implémentation. S'il est nommé, main()il doit suivre les formulaires indiqués ¹² :

  // implementation-defined name, or 
  int main ()
  int main (int argc, char *argv[])

Références

1. ANSI X3.159-1989 2.1.2.2 Environnement hébergé. "Démarrage du programme"

   La fonction appelée au démarrage du programme est nommée main. L'implémentation ne déclare aucun prototype pour cette fonction. Il doit être défini avec un type de retour de int et sans paramètres:

   int main(void) { /* ... */ } 

   ou avec deux paramètres (appelés ici argc et argv, bien que tous les noms puissent être utilisés, car ils sont locaux à la fonction dans laquelle ils sont déclarés):

   int main(int argc, char *argv[]) { /* ... */ }

2. ANSI X3.159-1989 2.1.2.1 Environnement autonome:

   Dans un environnement autonome (dans lequel l'exécution du programme C peut avoir lieu sans aucun avantage d'un système d'exploitation), le nom et le type de la fonction appelée au démarrage du programme sont définis par l'implémentation.

3. ISO 9899: 1999 5.1.2.2 Environnement hébergé -> 5.1.2.2.1 Démarrage du programme

   La fonction appelée au démarrage du programme est nommée main. L'implémentation ne déclare aucun prototype pour cette fonction. Il doit être défini avec un type de retour de int et sans paramètres:

   int main(void) { /* ... */ } 

   ou avec deux paramètres (appelés ici argc et argv, bien que tous les noms puissent être utilisés, car ils sont locaux à la fonction dans laquelle ils sont déclarés):

   int main(int argc, char *argv[]) { /* ... */ }

   ou équivalent; 9) ou d'une autre manière définie par la mise en œuvre.

4. Justification de la Norme internationale - Langages de programmation - C, révision 5.10. 5.1.2.2 Environnement hébergé -> 5.1.2.2.1 Démarrage du programme

   Le comportement des arguments à main et de l'interaction de sortie, main et atexit (voir §7.20.4.2) a été codifié pour limiter une variété indésirable dans la représentation des chaînes argv et dans le sens des valeurs renvoyées par main.

   La spécification d'argc et d'argv comme arguments de main reconnaît une pratique antérieure étendue. argv [argc] doit être un pointeur nul pour fournir un contrôle redondant pour la fin de la liste, également sur la base d'une pratique courante.

   main est la seule fonction qui peut être déclarée de manière portable avec zéro ou deux arguments. (Le nombre d'arguments d'autres fonctions doit correspondre exactement entre l'appel et la définition.) Ce cas spécial reconnaît simplement la pratique répandue de laisser les arguments à main lorsque le programme n'accède pas aux chaînes d'arguments du programme. Bien que de nombreuses implémentations prennent en charge plus de deux arguments pour main, une telle pratique n'est ni bénie ni interdite par la norme; un programme qui définit main avec trois arguments n'est pas strictement conforme (voir §J.5.1.).

5. ISO 9899: 1999 5.1.2.2 Environnement hébergé -> 5.1.2.2.3 Arrêt du programme

   Si le type de retour de la fonction principale est un type compatible avec int, un retour de l'appel initial à la fonction principale équivaut à appeler la fonction exit avec la valeur renvoyée par la fonction principale comme argument; 11) atteindre le }qui se termine la fonction principale renvoie une valeur de 0. Si le type de retour n'est pas compatible avec int, l'état de terminaison renvoyé à l'environnement hôte n'est pas spécifié.

6. ISO 9899: 1999 5.1.2.1 Environnement autonome

   Dans un environnement autonome (dans lequel l'exécution du programme C peut avoir lieu sans aucun avantage d'un système d'exploitation), le nom et le type de la fonction appelée au démarrage du programme sont définis par l'implémentation.

7. ISO 9899: 2011 5.1.2.2 Environnement hébergé -> 5.1.2.2.1 Démarrage du programme

   Cette section est identique à la C99 citée ci-dessus.

8. ISO 9899: 1999 5.1.2.1 Environnement autonome

   Cette section est identique à la C99 citée ci-dessus.

9. ISO 14882: 2003 3.6.1 Fonction principale

   Une implémentation ne doit pas prédéfinir la fonction principale. Cette fonction ne doit pas être surchargée. Il doit avoir un type de retour de type int, mais sinon son type est défini par l'implémentation. Toutes les implémentations doivent permettre les deux définitions suivantes de main:

   int main() { /* ... */ }

   et

   int main(int argc, char* argv[]) { /* ... */ }

10. ISO 14882: 2003 3.6.1 Fonction principale

    Il est défini par l'implémentation si un programme dans un environnement autonome est nécessaire pour définir une fonction principale.

11. ISO 14882: 2011 3.6.1 Fonction principale

    Une implémentation ne doit pas prédéfinir la fonction principale. Cette fonction ne doit pas être surchargée. Il doit avoir un type de retour de type int, mais sinon son type est défini par l'implémentation. Toutes les implémentations doivent permettre à la fois

    - une fonction de () retournant int et

    - une fonction de (int, pointeur vers pointeur vers char) renvoyant int

    comme type de principal (8.3.5).

12. ISO 14882: 2011 3.6.1 Fonction principale

    Cette section est identique à celle de C ++ 03 citée ci-dessus.

Retourne 0 en cas de succès et non nul pour l'erreur. Il s'agit de la norme utilisée par les scripts UNIX et DOS pour savoir ce qui s'est passé avec votre programme.

main() dans C89 et K&R C, les types de retour non spécifiés sont définis par défaut sur «int».

return 1? return 0?

1. Si vous n'écrivez pas de déclaration de retour dans int main(), la fermeture {renverra 0 par défaut.

2. return 0ou return 1sera reçu par le processus parent. Dans un shell, il va dans une variable shell, et si vous exécutez votre programme sous forme de shell et n'utilisez pas cette variable, vous n'avez pas à vous soucier de la valeur de retour de main().

Voir Comment puis-je obtenir ce que ma fonction principale a renvoyé? .

$ ./a.out
$ echo $?

De cette façon, vous pouvez voir que c'est la variable $?qui reçoit l'octet le moins significatif de la valeur de retour de main().

Dans les scripts Unix et DOS, return 0en cas de succès et non nul pour l'erreur sont généralement retournés. Il s'agit de la norme utilisée par les scripts Unix et DOS pour découvrir ce qui s'est passé avec votre programme et contrôler l'ensemble du flux.

Gardez à l'esprit que, même si vous retournez un entier, certains systèmes d'exploitation (Windows) tronquent la valeur renvoyée en un seul octet (0-255).

La valeur de retour peut être utilisée par le système d'exploitation pour vérifier la fermeture du programme.

La valeur de retour 0 signifie généralement OK dans la plupart des systèmes d'exploitation (ceux auxquels je pense de toute façon).

Il peut également être vérifié lorsque vous appelez un processus vous-même et voyez si le programme s'est terminé et s'est terminé correctement.

Ce n'est PAS seulement une convention de programmation.

La valeur de retour de main()montre comment le programme s'est arrêté. Si la valeur de retour est, zerocela signifie que l'exécution a réussi, tandis que toute valeur non nulle représentera que quelque chose s'est mal passé dans l'exécution.

J'avais l'impression que la norme spécifie que le principal n'a pas besoin d'une valeur de retour car un retour réussi était basé sur le système d'exploitation (zéro dans l'un pourrait être un succès ou un échec dans un autre), donc l'absence de retour était un signal pour le compilateur pour insérer le retour réussi lui-même.

Cependant, je retourne généralement 0.

Renvoyer 0 devrait indiquer au programmeur que le programme a correctement terminé le travail.

Omettre return 0

Lorsqu'un programme C ou C ++ atteint la fin du maincompilateur génère automatiquement du code pour retourner 0, il n'est donc pas nécessaire de mettre return 0;explicitement à la fin de main.

Remarque: lorsque je fais cette suggestion, elle est presque invariablement suivie d'un des deux types de commentaires: "Je ne le savais pas." ou "C'est un mauvais conseil!" Ma justification est qu'il est sûr et utile de s'appuyer sur le comportement du compilateur explicitement pris en charge par la norme. Pour C, depuis C99; voir ISO / IEC 9899: 1999 section 5.1.2.2.3:

[...] un retour de l'appel initial à la mainfonction équivaut à appeler la exitfonction avec la valeur renvoyée par la mainfonction comme argument; atteindre la }fin de la mainfonction renvoie une valeur de 0.

Pour C ++, depuis la première norme en 1998; voir ISO / IEC 14882: 1998 section 3.6.1:

Si le contrôle atteint la fin de main principale sans rencontrer de déclaration de retour, l'effet est celui de l'exécution du retour 0;

Depuis lors, toutes les versions des deux normes (C99 et C ++ 98) ont conservé la même idée. Nous nous appuyons sur les fonctions membres générées automatiquement en C ++, et peu de gens écrivent des return;instructions explicites à la fin d'une voidfonction. Les raisons de ne pas le faire semblent se résumer à "ça a l'air bizarre" . Si, comme moi, vous êtes curieux de connaître la justification du changement de la norme C, lisez cette question . Notez également qu'au début des années 90, cela était considéré comme une "pratique bâclée" car il s'agissait à l'époque d'un comportement indéfini (bien que largement soutenu).

En outre, les directives de base C ++ contiennent plusieurs instances d'omission return 0;à la fin mainet aucune instance dans laquelle un retour explicite est écrit. Bien qu'il n'y ait pas encore de directive spécifique sur ce sujet particulier dans ce document, cela semble au moins une approbation tacite de la pratique.

Je préconise donc de l'omettre; d'autres ne sont pas d'accord (souvent avec véhémence!) Dans tous les cas, si vous rencontrez du code qui l'omet, vous saurez qu'il est explicitement pris en charge par la norme et vous saurez ce que cela signifie.

Que retourner dépend de ce que vous voulez faire avec l'exécutable. Par exemple, si vous utilisez votre programme avec un shell de ligne de commande, vous devez retourner 0 pour un succès et un non nul pour un échec. Ensuite, vous pourrez utiliser le programme dans des shells avec un traitement conditionnel en fonction du résultat de votre code. Vous pouvez également attribuer une valeur différente de zéro selon votre interprétation, par exemple pour les erreurs critiques, différents points de sortie de programme pourraient terminer un programme avec différentes valeurs de sortie, et qui est disponible pour le shell appelant qui peut décider quoi faire en inspectant la valeur retournée. Si le code n'est pas destiné à être utilisé avec des shells et que la valeur renvoyée ne dérange personne, il peut être omis. J'utilise personnellement la signatureint main (void) { .. return 0; .. }

Si vous avez vraiment des problèmes liés à l'efficacité du retour d'un entier à partir d'un processus, vous devriez probablement éviter d'appeler ce processus tant de fois que cette valeur de retour devient un problème.

Si vous faites cela (appelez un processus tant de fois), vous devriez trouver un moyen de mettre votre logique directement dans l'appelant, ou dans un fichier DLL, sans allouer un processus spécifique pour chaque appel; les allocations de processus multiples vous posent le problème d'efficacité pertinent dans ce cas.

En détail, si vous voulez seulement savoir si le retour de 0 est plus ou moins efficace que le retour de 1, cela peut dépendre du compilateur dans certains cas, mais de manière générique, en supposant qu'ils sont lus à partir de la même source (local, champ, constant, intégré dans le code, le résultat de la fonction, etc.), il nécessite exactement le même nombre de cycles d'horloge.

Voici une petite démonstration de l'utilisation des codes retour ...

Lorsque vous utilisez les divers outils fournis par le terminal Linux, vous pouvez utiliser le code retour, par exemple pour la gestion des erreurs une fois le processus terminé. Imaginez que le fichier texte suivant myfile soit présent:

Ceci est un exemple afin de vérifier le fonctionnement de grep.

Lorsque vous exécutez la commande grep, un processus est créé. Une fois qu'il a traversé (et n'a pas cassé), il retourne du code entre 0 et 255. Par exemple:

$ grep order myfile

Si tu fais

$ echo $?
$ 0

vous obtiendrez un 0. Pourquoi? Parce que grep a trouvé une correspondance et a renvoyé un code de sortie 0, qui est la valeur habituelle pour quitter avec succès. Vérifions-le à nouveau mais avec quelque chose qui n'est pas dans notre fichier texte et donc aucune correspondance ne sera trouvée:

$ grep foo myfile
$ echo $?
$ 1

Étant donné que grep n'a pas réussi à faire correspondre le jeton "foo" avec le contenu de notre fichier, le code de retour est 1 (c'est le cas habituel en cas d'échec, mais comme indiqué ci-dessus, vous avez le choix entre de nombreuses valeurs).

Maintenant, le script bash suivant (tapez-le simplement dans un terminal Linux) bien que très basique devrait donner une idée de la gestion des erreurs:

$ grep foo myfile
$ CHECK=$?
$ [ $CHECK -eq 0] && echo 'Match found'
$ [ $CHECK -ne 0] && echo 'No match was found'
$ No match was found

Après la deuxième ligne, rien n'est imprimé sur le terminal car "foo" a fait grep retourner 1 et nous vérifions si le code de retour de grep était égal à 0. La deuxième instruction conditionnelle fait écho à son message dans la dernière ligne car elle est vraie en raison de CHECK == 1.

Comme vous pouvez voir si vous appelez ceci et ce processus, il est parfois essentiel de voir ce qu'il a retourné (par la valeur de retour de main ()).

Quelle est la manière correcte (la plus efficace) de définir la fonction main () en C et C ++ - int main () ou void main () - et pourquoi?

Ces mots «(le plus efficace)» ne changent pas la question. À moins que vous ne soyez dans un environnement autonome, il existe une façon universellement correcte de déclarer main(), et c'est comme retourner int.

Que devrait main()retourner en C et C ++?

Ce n'est pas ce qui devrait main() revenir, c'est ce qui main() revient. main()est, bien sûr, une fonction que quelqu'un d'autre appelle. Vous n'avez aucun contrôle sur le code qui appelle main(). Par conséquent, vous devez déclarer main()avec une signature de type correct pour correspondre à son appelant. Vous n'avez tout simplement pas le choix en la matière. Vous n'avez pas à vous demander ce qui est plus ou moins efficace, ou ce qui est meilleur ou pire style, ou quelque chose comme ça, car la réponse est déjà parfaitement bien définie, pour vous, par les normes C et C +. Suivez-les.

Si int main () alors retourne 1 ou retourne 0?

0 pour le succès, différent de zéro pour l'échec. Encore une fois, ce n'est pas quelque chose que vous devez (ou obtenir) choisir: il est défini par l'interface à laquelle vous êtes censé vous conformer.