main arguments de fonction et de ligne de commande

  • Article

Tous les programmes C++ doivent avoir une main fonction. Si vous essayez de compiler un programme C++ sans main fonction, le compilateur génère une erreur. (Les bibliothèques et static bibliothèques de liaison dynamique n’ont pas de main fonction.) La main fonction est l’endroit où votre code source commence l’exécution, mais avant qu’un programme entre dans la main fonction, tous les static membres de classe sans initialiseurs explicites sont définis sur zéro. Dans Microsoft C++, les objets globaux static sont également initialisés avant l’entrée .main Plusieurs restrictions s’appliquent à la main fonction qui ne s’applique pas à d’autres fonctions C++. La fonction main :

  • Impossible de surcharger (voir Surcharge de fonction).
  • Ne peut pas être déclaré en tant que inline.
  • Ne peut pas être déclaré en tant que static.
  • Son adresse ne peut pas être prise.
  • Ne peut pas être appelée à partir de votre programme.

Signature de la fonction main

La fonction main n’a pas de déclaration, car elle est intégrée au langage. Si elle en avait, la syntaxe de déclaration pour main ressemblerait à ceci :

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

Si aucune valeur de retour n’est spécifiée, mainle compilateur fournit une valeur de retour de zéro.

Arguments de ligne de commande standard

Arguments pour main autoriser l’analyse de ligne de commande pratique des arguments. Les types pour argc et argv sont définis par le langage. Les noms argc et argv sont traditionnels, mais vous pouvez les nommer comme vous le souhaitez.

Les définitions d’argument sont les suivantes :

argc
Entier qui contient le nombre d’arguments qui suivent .argv Le paramètre argc est toujours supérieur ou égal à 1.

argv
Tableau de chaînes terminées par le caractère NULL qui représentent les arguments de ligne de commande entrés par l’utilisateur du programme. Par convention, argv[0] est la commande avec laquelle le programme est appelé. argv[1] est le premier argument de ligne de commande. Le dernier argument de la ligne de commande est argv[argc - 1], et argv[argc] est toujours NULL.

Pour plus d’informations sur la suppression du traitement en ligne de commande, consultez Personnaliser le traitement en ligne de commande C++.

Remarque

Par convention, argv[0] est le nom du fichier du programme. Toutefois, sur Windows, il est possible de générer un processus à l’aide CreateProcessde . Si vous utilisez à la fois les premiers et les deuxième arguments (et lpCommandLine),lpApplicationNameargv[0] il se peut que le nom exécutable ne soit pas le nom exécutable. Vous pouvez utiliser GetModuleFileName pour récupérer le nom exécutable et son chemin d’accès complet.

Extensions spécifiques à Microsoft

Les sections suivantes décrivent le comportement spécifique à Microsoft.

Fonction wmain et _tmain macro

Si vous concevez votre code source pour utiliser des acteurs à l’échelle charUnicode, vous pouvez utiliser le point d’entrée spécifique à wmain Microsoft, qui est la version de l’acteur largechar de main. Voici la syntaxe de déclaration effective pour wmain:

int wmain();
int wmain(int argc, wchar_t *argv[]);

Vous pouvez également utiliser la macro spécifique à _tmainMicrosoft, qui est une macro de préprocesseur définie dans tchar.h. _tmain se résout à main moins d’être _UNICODE défini. Dans ce cas, _tmain est résolu à wmain. La _tmain macro et d’autres macros qui commencent _t par sont utiles pour le code qui doit générer des versions distinctes pour les ensembles d’acteurs étroits et larges char. Pour plus d’informations, consultez Utilisation de mappages de texte générique.

Retour void de main

En tant qu’extension Microsoft, les main fonctions peuvent wmain être déclarées comme retournant void (aucune valeur de retour). Cette extension est également disponible dans d’autres compilateurs, mais son utilisation n’est pas recommandée. Elle est disponible pour la symétrie quand main elle ne retourne pas de valeur.

Si vous déclarez ou retournezmain, vous ne pouvez pas retourner voidde exit code au processus parent ou au système d’exploitation à l’aide d’une return instruction.wmain Pour retourner un exit code quand main ou wmain est déclaré en tant que void, vous devez utiliser la exit fonction.

Argument de ligne de commande envp

wmain Les main signatures autorisent une extension facultative spécifique à Microsoft pour l’accès aux variables d’environnement. Cette extension est également courante dans d’autres compilateurs pour les systèmes Windows et UNIX. Le nom envp est traditionnel, mais vous pouvez nommer le paramètre d’environnement comme vous le souhaitez. Voici les déclarations effectives des listes d’arguments qui incluent le paramètre d’environnement :

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

envp
Le paramètre facultatif envp est un tableau de chaînes représentant les variables définies dans l’environnement de l’utilisateur. Ce tableau se termine par une entrée NULL. Il peut être déclaré en tant que tableau de pointeurs vers char (char *envp[]) ou en tant que pointeur char vers (char **envp). Si votre programme utilise wmain au lieu de , utilisez le wchar_t type de maindonnées au lieu de char.

Le bloc d’environnement passé et mainwmain est une copie « figée » de l’environnement actuel. Si vous modifiez ultérieurement l’environnement en effectuant un appel vers putenv ou _wputenv, l’environnement actuel (tel que retourné par getenv ou _wgetenv et par la _environ_wenviron variable) change, mais le bloc pointé par envp ne changera pas. Pour plus d’informations sur la suppression du traitement de l’environnement, consultez Personnaliser le traitement en ligne de commande C++. L’argument envp est compatible avec la norme C89, mais pas avec les normes C++.

Exemples d’arguments à main

L’exemple suivant montre comment utiliser les arguments et envp les argcargvarguments pour main:

// argument_definitions.cpp
// compile with: /EHsc
#include <iostream>
#include <string.h>

using namespace std;
int main( int argc, char *argv[], char *envp[] )
{
    bool numberLines = false;    // Default is no line numbers.

    // If /n is passed to the .exe, display numbered listing
    // of environment variables.
    if ( (argc == 2) && _stricmp( argv[1], "/n" ) == 0 )
         numberLines = true;

    // Walk through list of strings until a NULL is encountered.
    for ( int i = 0; envp[i] != NULL; ++i )
    {
        if ( numberLines )
            cout << i << ": "; // Prefix with numbers if /n specified
        cout << envp[i] << "\n";
    }
}

Analyse des arguments de ligne de commande C++

Les règles d’analyse de ligne de commande utilisées par le code Microsoft C/C++ sont spécifiques à Microsoft. Le code de démarrage du runtime utilise ces règles lors de l’interprétation des arguments donnés sur la ligne de commande du système d’exploitation :

  • Les arguments sont délimités par un espace blanc, qui peut être un espace ou une tabulation.

  • Le premier argument (argv[0]) est traité de manière spéciale. Il représente le nom du programme. Comme il doit s’agir d’un nom de chemin d’accès valide, les parties entourées de guillemets doubles (") sont autorisées. Les guillemets doubles ne sont pas inclus dans la sortie argv[0]. Les parties entourées de guillemets doubles empêchent l’interprétation d’un espace ou d’un acteur de tabulation charcomme fin de l’argument. Les règles suivantes répertoriées dans cette liste ne s’appliquent pas.

  • Une chaîne entourée de guillemets doubles est interprétée comme un argument unique, qui peut contenir des acteurs d’espace charblanc. Une chaîne entre guillemets peut être incorporée dans un argument. Le pointeur (^) n’est pas reconnu comme un acteur d’échappement charou un délimiteur. Dans une chaîne entre guillemets, une paire de guillemets doubles est interprétée comme un seul guillemet double échappé. Si la ligne de commande se termine avant qu’une guillemet double fermante soit trouvée, tous les characteurs lus jusqu’à présent sont de sortie comme dernier argument.

  • Un guillemet double précédé d’une barre oblique inverse (\") est interprété comme un guillemet double littéral (").

  • Les barres obliques inverses sont interprétées littéralement, sauf si elles précèdent immédiatement un guillemet double.

  • Si un nombre pair de barres obliques inverses est suivi d’un guillemet double, une barre oblique inverse (\) est placée dans le tableau argv pour chaque paire de barres obliques inverses (\\) et le guillemet double (") est interprété comme un délimiteur de chaîne.

  • Si un nombre impair de barres obliques inverses est suivi d’un guillemet double, une barre oblique inverse (\) est placée dans le tableau argv pour chaque paire de barres obliques inverses (\\). La marque de guillemets doubles est interprétée comme une séquence d’échappement par lamainbarre oblique inverse reing, ce qui entraîne la mise en argvplace d’un guillemet double littéral (") .

Exemple d’analyse d’argument de ligne de commande

Le programme suivant montre comment les arguments de ligne de commande sont passés :

// command_line_arguments.cpp
// compile with: /EHsc
#include <iostream>

using namespace std;
int main( int argc,      // Number of strings in array argv
          char *argv[],   // Array of command-line argument strings
          char *envp[] )  // Array of environment variable strings
{
    int count;

    // Display each command-line argument.
    cout << "\nCommand-line arguments:\n";
    for( count = 0; count < argc; count++ )
         cout << "  argv[" << count << "]   "
                << argv[count] << "\n";
}

Résultats de l’analyse des lignes de commande

Le tableau suivant présente un exemple d’entrée et de sortie attendue, illustrant les règles de la liste précédente.

Entrée de ligne de commande argv[1] argv[2] argv[3]
"abc" d e abc d e
a\\b d"e f"g h a\\b de fg h
a\\\"b c d a\"b c d
a\\\\"b c" d e a\\b c d e
a"b"" c d ab" c d

Développement des caractères génériques

Le compilateur Microsoft vous permet éventuellement d’utiliser des caractères génériques cartechar acters, le point d’interrogation (?) et l’astérisque (*), pour spécifier des arguments de nom de fichier et de chemin d’accès sur la ligne de commande.

Les arguments de ligne de commande sont gérés par une routine interne dans le code de démarrage du runtime, qui par défaut ne développe pas les caractères génériques carte dans des chaînes distinctes dans le argv tableau de chaînes. Vous pouvez activer l’extension wild carte en incluant le setargv.obj fichier (wsetargv.objfichier pour wmain) dans vos /link options de compilateur ou votre LINK ligne de commande.

Pour plus d’informations sur les options de l’éditeur de liens de démarrage du runtime, consultez Options de lien.

Personnaliser le traitement en ligne de commande C++

Si votre programme ne prend pas d’arguments de ligne de commande, vous pouvez supprimer la routine de traitement de ligne de commande pour économiser une petite quantité d’espace. Pour supprimer son utilisation, incluez le fichier noarg.obj (pour main et wmain) dans vos options de compilateur /link ou votre ligne de commande LINK.

De même, si vous n’accédez jamais à la table d’environnement par le biais de l’argument envp, vous pouvez supprimer la routine de traitement de l’environnement interne. Pour supprimer son utilisation, incluez le fichier noenv.obj (pour main et wmain) dans vos options de compilateur /link ou votre ligne de commande LINK.

Votre programme peut effectuer des appels à la famille de routines spawn ou exec dans la bibliothèque Runtime C. Si c’est le cas, vous ne devez pas supprimer la routine de traitement de l’environnement, car elle est utilisée pour transmettre un environnement du processus parent au processus enfant.

Voir aussi

Concepts de base