Que signifie int argc, char * argv []?

Dans de nombreux IDE et compilateurs C ++, lorsqu'il génère la fonction principale pour vous, il 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?

argvet argccomment les arguments de ligne de commande sont passés main()en C et C ++.

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

Les variables sont nommées argc( nombre d'arguments ) et argv( vecteur d'arguments ) par convention, mais elles peuvent recevoir n'importe quel identifiant valide: int main(int num_args, char** arg_strings)est également valide.

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

Essayez le programme suivant:

#include <iostream>

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;
    }
}

L'exécuter avec ./test a1 b2 c3affichera

Have 4 arguments:
./test
a1
b2
c3

argcest le nombre d'arguments transmis à votre programme à partir de la ligne de commande et argvest le tableau d'arguments.

Vous pouvez parcourir les arguments en connaissant le nombre d'entre eux 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 shsyntaxe):

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é comme si:

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

Cependant, si vous avez déclaré votre principal comme int main(), il sera appelé quelque chose comme

exit(main());

et vous ne faites pas passer les arguments.

Deux choses supplémentaires à noter:

1. Ce sont les deux seules signatures standard pour main. Si une plate-forme particulière accepte des arguments supplémentaires ou un type de retour différent, alors c'est une extension et ne doit pas être invoqué dans un programme portable.
2. *argv[]et **argvsont exactement équivalents, vous pouvez donc écrire en int main(int argc, char *argv[])tant que int main(int argc, char **argv).

Les paramètres pour mainreprésenter les paramètres de ligne de commande fournis au programme lors de son démarrage. Le argcparamètre représente le nombre d'arguments de 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.

La mainfonction peut avoir deux paramètres, argcet argv. argcest un intparamètre integer ( ), et c'est le nombre d'arguments passés au programme.

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

Le paramètre argvpointe vers un tableau de chaînes et est appelé le vecteur d'argument . Il s'agit d'un tableau de chaînes unidimensionnel d'arguments de fonction.

int main();

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

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

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

myprogram arg1 arg2 arg3

argc, ou Argument Count, sera défini sur 4 (quatre arguments) et argv, ou Argument Vectors, seront remplis avec des pointeurs de chaîne sur "myprogram", "arg1", "arg2" et "arg3". Le programme invocation ( myprogram) est inclus 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 ajouter:

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

Le envpparamètre 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 se termine par null.

IMPORTANT: N'UTILISEZ PAS les valeurs argvou envpdirectement dans les appels à system()! Il s'agit d'un énorme trou de sécurité, car des utilisateurs malveillants pourraient définir des variables d'environnement sur des commandes de ligne de commande et (potentiellement) causer des dommages massifs. En général, ne l'utilisez pas system(). Il existe presque toujours une meilleure solution implémentée via les bibliothèques C.

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.

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 pour votre fonction principale.