Quelle est la bonne déclaration de main?

Quelle est la signature correcte de la mainfonction en C ++? Quel est le type de retour correct et que signifie renvoyer une valeur main? Quels sont les types de paramètres autorisés et quelle est leur signification?

Ce système est-il spécifique? Ces règles ont-elles changé au fil du temps? Que se passe-t-il si je les enfreins?

La mainfonction doit être déclarée en tant que fonction non membre dans l'espace de noms global. Cela signifie qu'il ne peut pas être une fonction membre statique ou non statique d'une classe, ni ne peut être placé dans un espace de noms (même l'espace de noms sans nom).

Le nom mainn'est pas réservé en C ++ sauf en tant que fonction dans l'espace de noms global. Vous êtes libre de déclarer d'autres entités nommées main, y compris entre autres, des classes, des variables, des énumérations, des fonctions membres et des fonctions non membres qui ne sont pas dans l'espace de noms global.

Vous pouvez déclarer une fonction nommée en maintant que fonction membre ou dans un espace de noms, mais une telle fonction ne serait pas la mainfonction qui désigne le début du programme.

La mainfonction ne peut pas être déclarée comme staticou inline. Il ne peut pas non plus être surchargé; il ne peut y avoir qu'une seule fonction nommée maindans l'espace de noms global.

La mainfonction ne peut pas être utilisée dans votre programme: vous n'êtes pas autorisé à appeler la mainfonction de n'importe où dans votre code, ni à prendre son adresse.

Le type de retour de maindoit êtreint . Aucun autre type de retour n'est autorisé (cette règle est en gras car il est très courant de voir des programmes incorrects qui se déclarent mainavec un type de retour de void; c'est probablement la règle la plus fréquemment violée concernant la mainfonction).

Deux déclarations maindoivent être autorisées:

int main()               // (1)
int main(int, char*[])   // (2)

Dans (1) , il n'y a pas de paramètres.

Dans (2) , il y a deux paramètres et ils sont respectivement nommés argcet argv. argvest un pointeur vers un tableau de chaînes C représentant les arguments du programme. argcest le nombre d'arguments dans le argvtableau.

Habituellement, argv[0]contient le nom du programme, mais ce n'est pas toujours le cas. argv[argc]est garanti comme étant un pointeur nul.

Notez que comme un argument de type tableau (comme char*[]) n'est en réalité qu'un argument de type pointeur déguisé, les deux suivants sont tous deux des moyens valides d'écrire (2) et ils signifient tous deux exactement la même chose:

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

Certaines implémentations peuvent autoriser d'autres types et nombres de paramètres; vous devrez vérifier la documentation de votre implémentation pour voir ce qu'elle prend en charge.

main()est censé renvoyer zéro pour indiquer le succès et différent de zéro pour indiquer un échec. Vous n'êtes pas obligé d'écrire explicitement une returninstruction dans main(): si vous laissez main()return sans returninstruction explicite , c'est la même chose que si vous aviez écrit return 0;. Les deux main()fonctions suivantes ont le même comportement:

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

Il existe deux macros, EXIT_SUCCESSet EXIT_FAILURE, définies dans <cstdlib>qui peuvent également être renvoyées main()pour indiquer respectivement le succès et l'échec.

La valeur renvoyée par main()est transmise à la exit()fonction, qui met fin au programme.

Notez que tout cela ne s'applique que lors de la compilation pour un environnement hébergé (de manière informelle, un environnement dans lequel vous avez une bibliothèque standard complète et un système d'exploitation exécutant votre programme). Il est également possible de compiler un programme C ++ pour un environnement autonome (par exemple, certains types de systèmes embarqués), auquel cas le démarrage et l'arrêt sont entièrement définis par l'implémentation et une main()fonction peut même ne pas être requise. Si vous écrivez du C ++ pour un système d'exploitation de bureau moderne, vous compilez pour un environnement hébergé.

À partir de la documentation standard., 3.6.1.2 Fonction principale ,

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 depuis l'environnement dans lequel le programme est exécuté.Si argc est différent de zéro, ces arguments doivent être fournis dans argv [0] à argv [argc-1] comme pointeurs vers l'initial caractères des chaînes multi-octets terminées par null .....

J'espère que cela pourra aider..

Le libellé exact de la dernière norme publiée (C ++ 14) est:

Une mise en œuvre doit permettre à la fois

• une fonction de ()retour intet

• une fonction de (int, pointeur vers pointeur vers char)retourint

comme type de main.

Cela indique clairement que des orthographes alternatives sont autorisées tant que le type de mainest le type int()ou int(int, char**). Les éléments suivants sont donc également autorisés:

• int main(void)
• auto main() -> int
• int main ( )
• signed int main()
• typedef char **a; typedef int b, e; e main(b d, a c)

Les deux réseaux valides sont int main()et int main(int, char*[]). Toute autre chose peut être compilée ou non. Si mainne renvoie pas explicitement une valeur, 0 est retourné implicitement.

Détails sur les valeurs de retour et leur signification

Par 3.6.1 ( [basic.start.main]):

Une instruction return in maina pour effet de quitter la mainfonction (détruisant 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 mainsans rencontrer d' returninstruction, l'effet est celui de l'exécution

return 0;

Le comportement de std::exitest détaillé dans la section 18.5 ( [support.start.term]), et décrit le code d'état:

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