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


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


Il existe de nombreux doublons de cette question, notamment:

En relation:


549
2017-10-15 12:13


origine


Réponses:


La valeur de retour pour main devrait indiquer comment le programme est sorti. La sortie normale est généralement représentée par une valeur de retour 0 main. La terminaison anormale est généralement signalée par un retour non nul, mais il n'y a pas de norme pour l'interprétation des codes non nuls. Aussi comme noté par d'autres, void main() est explicitement interdit par la norme C ++ et ne doit pas être utilisé. Le C ++ valide main les signatures sont:

int main()

et

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

ce qui est équivalent à

int main(int argc, char** argv)

Il est également intéressant de noter qu'en C ++, int main() peut être laissé sans valeur de retour, auquel cas il retourne 0 par défaut. Cela est également vrai avec un programme C99. Si le retour 0 doit être omis ou non est ouvert au débat. La gamme des signatures principales du programme C valide est beaucoup plus grande.

En outre, l'efficacité n'est pas un problème avec main fonction. Il ne peut être entré et quitté qu'une seule fois (marquage du début et de la fin du programme) selon la norme C ++. Pour C, l'affaire est différente et ré-entrer main() est autorisé, mais devrait probablement être évité.


466
2017-10-15 12:16



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

ISO / CEI 9899: 1989 (C90):

main() devrait être déclaré comme:

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

Ou équivalent. Par exemple, int main(int argc, char *argv[]) est équivalent à la seconde. En outre, le int Le type de retour peut être omis car c'est un défaut.

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

La norme définit 3 valeurs de retour strictement conformes (c'est-à-dire ne reposant pas sur le comportement défini par l'implémentation): 0 et EXIT_SUCCESS pour une résiliation réussie, et EXIT_FAILURE pour une résiliation infructueuse. Toutes les autres valeurs sont non standard et implémentées. main() doit avoir un explicite return déclaration à la fin pour éviter un comportement indéfini.

Enfin, il n'y a rien de mal du point de vue des normes avec l'appel main()d'un programme.

ISO / CEI 9899: 1999 (C99):

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

  • le int Le type de retour ne peut pas être omis.
  • Vous pouvez omettre la déclaration de retour de main(). Si vous le faites, et main() fini, il y a un implicite return 0.

137
2017-10-16 09:59



Standard C - Environnement hébergé

Pour un environnement hébergé (c'est 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 pas   prototype pour cette fonction. Il doit être défini avec un type de retour int et sans   paramètres:

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

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

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

ou équivalent;dix) ou d'une autre manière définie par l'implémentation.

Si elles sont déclarées, les paramètres de la fonction principale doivent obéir aux   contraintes:

  • La valeur de argc doit être non négatif.
  • argv[argc] doit être un pointeur nul.
  • Si la valeur de argc est supérieur à zéro, les membres du tableau argv[0] par    argv[argc-1] inclusive doit contenir des pointeurs sur les chaînes, qui sont donnés   valeurs définies par l'implémentation par l'environnement hôte avant le démarrage du programme. le   l'intention est de fournir au programme les informations déterminées avant le démarrage du programme   d'ailleurs dans 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 s'assurer que les chaînes sont reçues en minuscules.
  • Si la valeur de argc est supérieur à 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   le nom du programme n'est pas disponible dans l'environnement hôte. Si la valeur de argc est   supérieur à un, les chaînes pointées par argv[1] par argv[argc-1]   représenter les paramètres du programme.
  • Les paramètres argc et argv et les chaînes pointées par le argv tableau doit   être modifiable par le programme, et conserver leurs dernières valeurs stockées entre le programme   démarrage et arrêt du programme.

dix) Ainsi, int peut être remplacé par un nom de typedef défini comme intou le type de argv peut être écrit comme    char **argv, etc.

Fin du programme en C99 ou C11

La valeur renvoyée par main() est transmis à '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 main fonction est un type compatible avec int, un retour de   appel initial à la main fonction équivaut à appeler le exit fonctionner avec la valeur   retourné par le main fonctionner comme argument;11) atteindre le } qui termine le    main La fonction renvoie la valeur 0. Si le type de retour n'est pas compatible avec int, la   Le statut de terminaison renvoyé à l'environnement hôte n'est pas spécifié.

11)Conformément au 6.2.4, les durées de vie des objets ayant une durée de stockage automatique déclarée main   aura fini dans le premier cas, même où ils n'auraient pas dans le dernier cas.

Notez que 0 est mandaté comme «succès». Vous pouvez utiliser EXIT_FAILURE et EXIT_SUCCESS de <stdlib.h> si vous préférez, mais 0 est bien établi, et est donc 1. Voir aussi Les codes de sortie supérieurs à 255 - possibles?.

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

7.22.4.4 Le exit fonction

¶5 Enfin, le contrôle est renvoyé à l'environnement hôte. Si la valeur de status est zéro ou EXIT_SUCCESS, une forme définie par l'implémentation du statut résiliation réussie est retourné. Si la valeur de status est EXIT_FAILURE, une forme définie par l'implémentation du statut résiliation infructueuse est retourné. 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. Cela devrait   avoir un type de retour de type int, mais sinon son type est défini par l'implémentation.   Toutes les implémentations   doit permettre les deux définitions suivantes de principal:

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

et

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

Dans la dernière forme argc doit être le nombre d'arguments passés au programme depuis l'environnement   dans lequel le programme est exécuté. Si argc est non nul ces arguments doivent être fournis dans argv[0]   par argv[argc-1] comme pointeurs sur les caractères initiaux des chaînes multi-octets à terminaison nulle (NTMBS) (17.5.2.1.4.2) et argv[0] doit être le pointeur vers le caractère initial d'un NTMBS qui représente le   nom utilisé pour invoquer le programme ou "". La valeur de argc doit être non négatif. La valeur de argv[argc]   doit être 0. [Remarque: Il est recommandé d'ajouter d'autres paramètres (facultatifs) après argv. -fin   Remarque ]

¶3 La fonction main ne doit pas être utilisé dans un programme. Le lien (3.5) de main est défini par l'implémentation. [...]

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

return 0;

Le standard C ++ dit explicitement "It [la fonction principale] doit avoir un type de retour de type int, mais sinon son type est défini par l'implémentation ", et nécessite les deux mêmes signatures que le standard C pour être supporté en tant qu'options.Ainsi, un 'void main ()' est directement interdit par le standard C ++, bien qu'il n'y ait rien à faire arrêtez une implémentation non standard permettant des alternatives Notez que C ++ interdit à l'utilisateur d'appeler main(mais pas la norme C).

Il y a un paragraphe de §18.5 Début et fin dans la norme C ++ 11 identique au paragraphe du § 7.2.2.4 le exit fonction dans la norme C11 (citée ci-dessus), à l'exception d'une note de bas de page EXIT_SUCCESS et EXIT_FAILURE sont définis 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 terminés par des caractères NULL, dont chacun est 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;'. Pendant longtemps, cela n'a pas eu un en-tête qui l'a déclaré, mais le POSIX La norme 2008 exige maintenant qu'elle soit déclarée <unistd.h>.

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 terminés par null à char, chacun d'eux pointe 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 Microsoft VS 2010 le compilateur est intéressant. Le site web dit:

La syntaxe de déclaration pour principal est

 int main();

ou, en option,

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

Alternativement, le main et wmain les fonctions peuvent être déclarées comme retournant void (pas de valeur de retour). Si vous déclarez main ou wmain En tant qu'annulation de retour, 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 main ou wmain est déclaré comme void, vous devez utiliser le exit fonction.

Il ne me semble pas clair ce qui se passe (quel code de sortie est retourné au parent ou à l'OS) quand un programme avec void main() quitte - et le site Web de MS est silencieux aussi.

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

La page Microsoft énumère également d'autres alternatives - wmain() qui prend des chaînes de caractères larges, et un peu plus.

Le Microsoft Visual Studio 2005 version de cette page ne liste pas void main() comme alternative. le versions de Microsoft Visual Studio 2008 en avant faire.

Norme C - Environnement autoportant

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é), alors 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 main et il n'y a pas de contraintes 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'exécution   environnement. Tous les objets ayant 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 de cette initialisation sont par ailleurs non 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 bénéficier 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. Toute bibliothèque disponible pour un programme autonome, autre que l'ensemble minimal requis par la clause 4, est définie par l'implémentation.

L'effet de la terminaison du programme dans un environnement autonome est défini par l'implémentation.

La référence croisée à la clause 4 Conformité se réfère à ceci:

¶5 A programme strictement conforme ne doit utiliser que les caractéristiques de la langue et de la bibliothèque spécifiées dans la présente Norme internationale.3) Il ne doit pas produire de résultat dépendant d'un comportement non spécifié, indéfini ou défini par l'implémentation, et ne doit pas dépasser toute limite d'implémentation minimale.

¶6 Les deux formes de mise en œuvre conforme sont hébergé et autoportant. UNE implémentation hébergée conforme doit accepter tout programme strictement conforme. UNE implémentation autoportante conforme doit accepter tout programme strictement conforme dans lequel l'utilisation des fonctionnalités spécifiées dans la clause de la bibliothèque (clause 7) est limitée au contenu des en-têtes standard <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   fonctions supplémentaires de la bibliothèque), à ​​condition qu'ils ne modifient pas le comportement de tout programme strictement conforme.4)

¶7 A programme conforme est celui qui est acceptable pour une implémentation conforme.5)

3) Un programme strictement conforme peut utiliser des caractéristiques 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

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

5) Les programmes strictement conformes sont conçus pour être portables au maximum parmi les implémentations conformes. Les programmes conformes peuvent dépendre de caractéristiques 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 ceux-ci peuvent être - et sont souvent - juste des macros).

Standard C ++ - Environnement autoportant

Tout comme la norme C reconnaît les environnements hébergés et autonomes, la norme C ++ le permet également. (Citations de l'ISO / CEI 14882: 2011.)

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

¶7 Deux types d'implémentation sont définis: un implémentation et un mise en œuvre autonome. Pour une implémentation hébergée, la présente Norme internationale définit l'ensemble des bibliothèques disponibles. Un autoportant   la mise en œuvre est une implémentation dans laquelle l'exécution peut avoir lieu sans le bénéfice 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 de support de langage (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 de tout programme bien formé. Des implémentations sont nécessaires pour diagnostiquer les programmes   utiliser des extensions qui sont mal formées conformément à la présente Norme internationale. Cela fait, cependant, ils peuvent compiler et exécuter de tels programmes.

¶9 Chaque mise en œuvre doit inclure une documentation qui identifie toutes les constructions prises en charge de manière conditionnelle et ne définit pas les caractéristiques spécifiques à la localisation.3

3) 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émentation 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 inclure au moins les en-têtes du tableau 16.

La version fournie de l'en-tête <cstdlib> déclare au moins les fonctions abort, atexit, at_quick_exit, exit, et quick_exit (18,5). Les autres en-têtes répertoriés dans ce tableau doivent satisfaire 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>

Pourquoi ne pas utiliser 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 sont seulement 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, il suggère que int main() n'est pas interdit, même si ce n'est pas la notation préférée.

6.5.3.4 Le sizeof et _Alignof les opérateurs

...

¶8 EXEMPLE 3 Dans cet exemple, la taille d'un tableau de longueur variable est calculée et renvoyée à partir d'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;
}

98
2017-09-10 14:15



je crois que main() devrait retourner soit EXIT_SUCCESS ou EXIT_FAILURE. Ils sont définis dans stdlib.h


56
2017-10-15 12:33



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


27
2017-10-15 12:16



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

  • Environnement hébergé C90

    Formulaires autorisés 1:

    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 déclarés comme les formes autorisées, les autres sont implicitement autorisés car C90 a permis "implicite int" pour le type de retour et les paramètres de fonction. Aucune autre forme n'est autorisée.

  • Environnement autonome C90

    Tout formulaire ou nom de principal est autorisé 2.

  • Environnement hébergé C99

    Formulaires autorisés 3:

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

    Commentaires:

    C99 supprimé "implicite int" afin main() n'est plus valide.

    Une phrase étrange, ambiguë "ou d'une autre manière définie par l'implémentation" a été introduite. Cela peut soit être interprété comme "les paramètres de int main() peut varier "ou" principal peut avoir un formulaire défini par l'implémentation ".

    Certains compilateurs ont choisi d'interpréter la norme de cette manière. Sans doute, on ne peut pas facilement dire qu'ils ne se conforment pas strictement en citant la norme en soi, puisqu'elle est ambiguë.

    Cependant, pour permettre des formes complètement sauvages de main() é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  4.

    Pourtant, la section pour la terminaison du programme de l'environnement hébergé continue à se disputer sur le cas où main ne retourne pas int 5. Bien que cette section ne soit pas normative quant à la façon dont la fonction principale doit être déclarée, elle implique clairement que la fonction principale peut être déclarée d'une manière complètement mise en œuvre, même sur les systèmes hébergés.

  • Environnement autonome C99

    Tout formulaire ou nom de principal est autorisé 6.

  • Environnement hébergé C11

    Formulaires autorisés 7:

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

    Tout formulaire ou nom de principal est autorisé 8.


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 au C ++, () et (void) avoir des significations différentes. Le premier est un élément obsolète qui peut être retiré de la langue. Voir les directions linguistiques futures du C11:

6.11.6 Les déclarateurs de fonction

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


  • Environnement hébergé C ++ 03

    Formulaires autorisés 9:

    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. Si c'est nommé main() il doit suivre les formes indiquées dix:

    // implementation-defined name, or 
    int main ()
    int main (int argc, char *argv[])
    
  • Environnement hébergé C ++ 11

    Formulaires autorisés 11:

    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. Si c'est nommé main() il doit suivre les formes indiquées 12:

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

Les 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 appelée main. le   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ètre:

    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 à   fonction dans laquelle ils sont déclarés):

    int main(int argc, char *argv[]) { /* ... */ }
    
  2. ANSI X3.159-1989 2.1.2.1 Environnement autoportant:

    Dans un environnement autonome (dans lequel l'exécution du programme C peut prendre   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éfinies 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 appelée main. le   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ètre:

    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 à   fonction dans laquelle ils sont déclarés):

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

    ou équivalent 9) ou dans d'autres implémentations définies   manière.

  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 exit, main et atexit   (voir §7.20.4.2) a été codifié pour réduire une variété indésirable dans la représentation de   chaînes, et dans le sens des valeurs renvoyées par main.

    La spécification de argc et argv comme arguments à 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 de la pratique courante.

    main est la seule fonction qui peut être déclarée de façon portative avec zéro ou deux arguments. (Le nombre d'arguments d'autres fonctions doit correspondre exactement entre l'invocation et la définition.)   Ce cas particulier reconnaît simplement la pratique répandue de laisser les arguments à main lorsque le programme n'accède pas aux chaînes d'argument du programme. Bien que de nombreuses implémentations supportent plus de deux arguments, 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 Fin de 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; } qui termine la fonction principale renvoie une valeur de 0. Si le type de retour n'est pas compatible avec int, le statut 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 bénéficier 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 requis 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 () retourne int et

    - une fonction de (int, pointeur vers un pointeur sur char) retournant int

    comme le type de principal (8.3.5).

  12. ISO 14882: 2011 3.6.1 Fonction principale

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


25
2017-07-07 08:07



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


7
2017-10-15 15:22



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 une déclaration de retour dans int main(), la fermeture { retournera 0 par défaut.

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

Voir Comment puis-je obtenir ce que ma fonction principale est revenue?.

$ ./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 0 en cas de succès et non-zéro pour l'erreur sont généralement retournés. C'est la norme utilisée par les scripts Unix et DOS pour savoir ce qui s'est passé avec votre programme et contrôler l'ensemble du flux.


6
2017-12-27 08:02



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 que je peux penser de toute façon).

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

Ses NE PAS juste une convention de programmation.


4
2017-07-01 16:32



J'étais sous 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 un pourrait être un succès ou un échec dans un autre), donc l'absence de retour compilateur pour insérer le retour réussi lui-même.

Cependant, je retourne habituellement 0.


2
2017-10-15 12:42