Namespaces
Variants

Main function

From cppreference.net

Chaque programme C codé pour s'exécuter dans un environnement d'exécution hébergé contient la définition (et non le prototype) d'une fonction nommée main , qui désigne le point de départ du programme.

int main (void) { corps } (1)
int main ( int argc , char * argv [ ] ) { corps } (2)
/* autre signature définie par l'implémentation */ (depuis C99) (3)

Table des matières

Paramètres

argc - Valeur non négative représentant le nombre d'arguments passés au programme depuis l'environnement d'exécution.
argv - Pointeur vers le premier élément d'un tableau de argc + 1 pointeurs, dont le dernier est nul et les précédents, s'ils existent, pointent vers des chaînes représentant les arguments passés au programme depuis l'environnement hôte. Si argv [ 0 ] n'est pas un pointeur nul (ou, de manière équivalente, si argc > 0), il pointe vers une chaîne représentant le nom du programme, qui est vide si le nom du programme n'est pas disponible depuis l'environnement hôte.

Les noms argc et argv signifient "argument count" et "argument vector", et sont traditionnellement utilisés, mais d'autres noms peuvent être choisis pour les paramètres, ainsi que des déclarations différentes mais équivalentes de leur type : int main ( int ac, char ** av ) est également valide.

Une implémentation courante définie par la norme pour main est int main ( int argc, char * argv [ ] , char * envp [ ] ) , où un troisième argument, de type char ** , pointant vers un tableau de pointeurs vers les variables d'environnement d'exécution , est ajouté.

Valeur de retour

Si l'instruction return est utilisée, la valeur de retour est utilisée comme argument pour l'appel implicite à exit() (voir ci-dessous pour plus de détails). Les valeurs zéro et EXIT_SUCCESS indiquent une terminaison réussie, la valeur EXIT_FAILURE indique une terminaison échouée.

Explication

La fonction main est appelée au démarrage du programme, après l'initialisation de tous les objets ayant une durée de stockage statique. C'est le point d'entrée désigné d'un programme exécuté dans un environnement hébergé (c'est-à-dire avec un système d'exploitation). Le nom et le type du point d'entrée de tout programme autonome (chargeurs d'amorçage, noyaux de système d'exploitation, etc.) sont définis par l'implémentation.

Les paramètres de la forme à deux paramètres de la fonction principale permettent de transmettre des chaînes de caractères multioctets arbitraires depuis l'environnement d'exécution (elles sont généralement appelées arguments de ligne de commande ). Les pointeurs argv [ 1 ] .. argv [ argc - 1 ] pointent vers les premiers caractères de chacune de ces chaînes. argv [ 0 ] (s'il n'est pas nul) est le pointeur vers le caractère initial d'une chaîne multioctet terminée par un nul qui représente le nom utilisé pour invoquer le programme lui-même (ou, si cela n'est pas pris en charge par l'environnement hôte, argv [ 0 ] [ 0 ] est garanti être zéro).

Si l'environnement hôte ne peut pas fournir à la fois des lettres minuscules et majuscules, les arguments de ligne de commande sont convertis en minuscules.

Les chaînes sont modifiables, et toute modification effectuée persiste jusqu'à la fin du programme, bien que ces modifications ne se propagent pas vers l'environnement hôte : elles peuvent être utilisées, par exemple, avec strtok .

La taille du tableau pointé par argv est au moins de argc+1 , et le dernier élément, argv[argc] , est garanti d'être un pointeur nul.

La fonction main possède plusieurs propriétés spéciales :

1) Un prototype pour cette fonction ne peut pas être fourni par le programme.
2) Si le type de retour de la fonction main est compatible avec int , alors le retour de l'appel initial à main (mais pas le retour de tout appel récursif ultérieur) est équivalent à l'exécution de la fonction exit , avec la valeur retournée par la fonction main passée comme argument (ce qui appelle ensuite les fonctions enregistrées avec atexit , vide et ferme tous les flux, et supprime les fichiers créés avec tmpfile , puis retourne le contrôle à l'environnement d'exécution).
3)

Si la fonction main exécute un return qui ne spécifie aucune valeur ou, ce qui revient au même, atteint l'accolade fermante } sans exécuter un return , le statut de terminaison renvoyé à l'environnement hôte est indéfini.

(jusqu'à C99)

Si le type de retour de la fonction main n'est pas compatible avec int (par ex. void main ( void ) ), la valeur renvoyée à l'environnement hôte n'est pas spécifiée. Si le type de retour est compatible avec int et que le contrôle atteint l'accolade fermante } , la valeur renvoyée à l'environnement est la même que si on exécutait return 0 ; .

(depuis C99)

Exemple

Montre comment indiquer à un programme où trouver ses données d'entrée et où écrire ses résultats. Invocation : ./a.out fichier_entrée fichier_sortie

#include <stdio.h>
int main(int argc, char *argv[])
{
    printf("argc = %d\n", argc);
    for (int ndx = 0; ndx != argc; ++ndx)
        printf("argv[%d] --> %s\n", ndx, argv[ndx]);
    printf("argv[argc] = %p\n", (void*)argv[argc]);
}

Sortie possible :

argc = 3
argv[0] --> ./a.out
argv[1] --> indatafile
argv[2] --> outdatafile
argv[argc] = (nil)

Références

  • Norme C23 (ISO/CEI 9899:2024) :
  • 5.1.2.2.1 Démarrage du programme (p: TBD)
  • Norme C17 (ISO/CEI 9899:2018) :
  • 5.1.2.2.1 Démarrage du programme (p: 10-11)
  • Norme C11 (ISO/IEC 9899:2011):
  • 5.1.2.2.1 Démarrage du programme (p: 13)
  • Norme C99 (ISO/IEC 9899:1999) :
  • 5.1.2.2.1 Démarrage du programme (p: 12)
  • Norme C89/C90 (ISO/CEI 9899:1990) :
  • 5.1.2.2 Environnement hébergé

Voir aussi

Documentation C++ pour la main function