Que signifie int argc, char * argv ?

Dans de nombreux IDE et compilateurs C ++, quand il génère la fonction principale pour vous, cela ressemble à ceci:

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

Lorsque je code C ++ sans IDE, juste avec un compilateur en ligne de commande, je tape:

 int main() 

sans aucun paramètre. Qu’est-ce que cela signifie, et est-ce vital pour mon programme?

argv et argc sont comment les arguments de ligne de commande sont transmis à main() en C et C ++.

argc sera le nombre de chaînes pointées par argv . Cela sera (en pratique) égal à 1 plus le nombre d’arguments, car pratiquement toutes les implémentations appendont le nom du programme au tableau.

Les variables sont appelées argc ( nombre d’arguments ) et argv ( vecteur d’arguments ) par convention, mais on peut leur donner tout identifiant valide: int main(int num_args, char** arg_ssortingngs) est également valide.

Ils peuvent également être omis entièrement, cédant int main() , si vous n’avez pas l’intention de traiter les arguments de ligne de commande.

Essayez le programme suivant:

 #include  int main(int argc, char** argv) { std::cout < < "Have " << argc << " arguments:" << std::endl; for (int i = 0; i < argc; ++i) { std::cout << argv[i] << std::endl; } } 

Le ./test a1 b2 c3 avec ./test a1 b2 c3 va sortir

 Have 4 arguments: ./test a1 b2 c3 

argc est le nombre d’arguments passés dans votre programme à partir de la ligne de commande et argv est le tableau des arguments.

Vous pouvez parcourir les arguments en connaissant le nombre comme:

 for(int i = 0; i < argc; i++) { // argv[i] is the argument at index i } 

Supposons que vous exécutiez votre programme ainsi (en utilisant la syntaxe sh ):

 myprog arg1 arg2 'arg 3' 

Si vous avez déclaré votre main comme int main(int argc, char *argv[]) , alors (dans la plupart des environnements), votre main() sera appelée comme si:

 p = { "myprog", "arg1", "arg2", "arg 3", NULL }; exit(main(4, p)); 

Cependant, si vous avez déclaré votre main comme int main() , cela s’appellera quelque chose comme

 exit(main()); 

et vous n’obtenez pas les arguments.

Deux autres points à noter:

  1. Ce sont les deux seules signatures obligatoires pour le main . Si une plate-forme particulière accepte des arguments supplémentaires ou un type de retour différent, alors cette extension ne doit pas être utilisée dans un programme portable.
  2. *argv[] et **argv sont exactement équivalents, vous pouvez donc écrire int main(int argc, char *argv[]) comme int main(int argc, char **argv) .

Les parameters main représentent les parameters de ligne de commande fournis au programme lors de son démarrage. Le paramètre argc représente le nombre d’arguments de la ligne de commande et char *argv[] est un tableau de chaînes (pointeurs de caractères) représentant les arguments individuels fournis sur la ligne de commande.

Le premier paramètre est le nombre d’arguments fournis et le second paramètre est une liste de chaînes représentant ces arguments.

La fonction main peut avoir deux parameters, argc et argv . argc est un paramètre entier ( int ) et c’est le nombre d’arguments transmis au programme.

Le nom du programme est toujours le premier argument, il y aura donc au moins un argument pour un programme et la valeur minimale de argc sera un. Mais si un programme a lui-même deux arguments, la valeur de argc sera trois.

Le paramètre argv pointe sur un tableau de chaînes et s’appelle le vecteur d’argument . C’est un tableau de chaîne à une dimension contenant des arguments de fonction.

 int main(); 

Ceci est une simple déclaration. Il ne peut prendre aucun argument de ligne de commande.

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

Cette déclaration est utilisée lorsque votre programme doit prendre des arguments de ligne de commande. Lorsqu’il est exécuté comme tel:

 myprogram arg1 arg2 arg3 

argc , ou nombre d’arguments, sera défini sur 4 (quatre arguments), et argv , ou vecteurs d’arguments, sera rempli avec des pointeurs de chaîne vers “monprogramme”, “arg1”, “arg2” et “arg3”. L’invocation du programme ( myprogram ) est incluse dans les arguments!

Alternativement, vous pouvez utiliser:

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

Ceci est également valable.

Il y a un autre paramètre que vous pouvez append:

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

Le paramètre envp contient également des variables d’environnement. Chaque entrée suit ce format:

 VARIABLENAME=VariableValue 

comme ça:

 SHELL=/bin/bash 

La liste des variables d’environnement est terminée par un caractère nul.

IMPORTANT: N’utilisez PAS de valeurs argv ou envp directement dans les appels à system() ! Ceci est une énorme faille de sécurité car les utilisateurs malveillants peuvent définir des variables d’environnement sur des commandes de ligne de commande et (potentiellement) provoquer des dégâts considérables. En général, n’utilisez simplement pas system() . Il y a presque toujours une meilleure solution implémentée par les bibliothèques C.

Les deux

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

sont des définitions légales du point d’entrée d’un programme C ou C ++. Stroustrup: FAQ sur le style et la technique C ++ détaille certaines des variations possibles ou légales de votre fonction principale.