Discussion :

[membreComplexe12]

Bonjour tous,

je ne suis pas informaticien mais j'ai besoin de faire un peu de programmation donc ne vous affolez pas si mes question paraissent bete...

j'ai deja programmé en C et à present des imperatifs m'ammenent à programmer en C++, j'ai deux questions à propos du C++ et de la fonction main

1°) en C j'avais l'habitude d'utiliser:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int main()
{
}

Or la la personne dont je dois prendre le relais de la programmation utilise:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
int main(int argc, char **argv)
{
}

===> Quelle est la différence entre les deux? pourquoi le main aurait il besoin de prendre des arguments?
===> Pourquoi il y a deux etoiles devant argv?? c'est un double pointeur?

2°) j'ai cru comprendre que l'on pouvais rentrer des arguments avec code block à notre main en faisant:

(barre des menus) ==> project ==> Set arguments...

==> à quoi cela sert il ?

==> si je rentre par exemple comme argument 1 2
es ce que cela va me donner:

int argc=1 char **argv=2 ????

et si oui quel signification pour ces deux arguments que je ne connais pas?



merci d'avance pour votre aide

[Terry-Slipknot]

Tout d'abord, la deuxième syntaxe n'est pas spécifique au C++, elle est aussi présente en C...
Regarde ici: http://c.developpez.com/faq/index.ph...t#ENV_cmd_line
Si ton programme est un programme de type commande, les paramètres sont très utilisés. Tu peut donc lancer ton exécutable comme ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

tonappli arg1 arg2 "argument 3"

Ensuite, la syntaxe: **argv est un pointeur qui pointe sur un autre pointeur. Cette forme est aussi utilisé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

char *argv[]

Le reste est expliqué dans la FAQ !

[ram-0000]

Salut,

Les 2 formes int main() ou int main(int argc, char **argv) sont valides. Il en existe même une 3eme forme qui est int main(int argc, char **argv, char **envp).

Maintenant, quand est ce que l'on utilise une forme plutôt qu'une autre, cela dépend de ce dont le développeur à besoin.

Dans le 1er cas, on dit au compilateur que la fonction main() n'a pas de paramètres.

Dans le 2eme cas, on dit au compilateur C que la fonction main() à des paramètres et dans ce cas, la seule manière autorisée de décrire la fonction main() est int main(int argc, char **argv). On peut toutefois changer les noms des paramètres argc et argv (mais par leurs types) mais c'est une habitude courante de les appeler argc et argv. Dans ce cas, les argc est le nombre de paramètres passés à la fonction et argv un tableau de pointeurs de caractères (d'où la double **) sur les différents paramètres.
Par exemple, si on appelle le programme en ligne de commande comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
programme.exe toto 12 tata 23, 
argv[0] = "programme.exe";
argv[1] = "toto";
argv[2] = "12";
argv[3] = "tata";
argv[4] = "23";
argv[5] = NULL;
argc = 5;

argc est le nombre de paramètres contenus dans le tableau argv. A remarquer aussi qu'il est garanti que la dernière valeur valide de argv (argv[5] dans l'exemple) vaut NULL, c'est obligatoire.

Une autre remarque concernant argv[0], dans mon exemple, c'est le nom du programme appelé, suivant les OS, ce nom contiendra aussi éventuellement le chemin du binaire. Le nom du binaire est obligatoire mais pas forcément son chemin (les joies de l'informatique ).

Si l'analyse des paramètres de la fonction main() est bien faite, on s'aperçoit que le paramètre argc n'est pas utile (à cause justement du NULL qui ferme le tableau argv) mais il est là. Après, tu l'utilises ou pas, c'est comme tu veux.

En ce qui concerne la 3eme forme int main(int argc, char **argv, char **envp), le 3eme paramètre est un tableau de pointeurs de caractères constitué de la même manière que argv avec un NULL qui ferme la marche. Ce tableau contient les variables d'environnement ainsi que leur valeurs. Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
envp[0] contient "TEMP=/tmp"
envp[1] contient "TMP=/tmp"
envp[2] contient "PATH=/usr/bin"
...
envp[x] contient NULL

Ce programme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int main(int argc, char **argv, char **envp)
{
int boucle;
 
	printf("argc=%d\n", argc);
	printf("\n");
 
	for(boucle = 0; argv[boucle] != NULL; boucle++)
	{
		printf("argv[%d]=%s\n", boucle, argv[boucle]);
	}
	printf("\n");
 
	for(boucle = 0; envp[boucle] != NULL; boucle++)
	{
		printf("envp[%d]=%s\n", boucle, envp[boucle]);
	}
	printf("\n");
	return 0;
}

génère ce résultat

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
argc=5
 
argv[0]=d:\Raymond\Developpement\Test\TestMain\Debug\TestMain.exe
argv[1]=toto
argv[2]=12
argv[3]=tata
argv[4]=23
 
envp[0]=ALLUSERSPROFILE=C:\ProgramData
envp[1]=APPDATA=C:\Users\Raymond\AppData\Roaming
envp[2]=CommonProgramFiles=C:\Program Files (x86)\Common Files
envp[3]=CommonProgramFiles(x86)=C:\Program Files (x86)\Common Files
envp[4]=CommonProgramW6432=C:\Program Files\Common Files
envp[5]=COMPUTERNAME=LUMIERE
envp[6]=ComSpec=C:\Windows\system32\cmd.exe
envp[7]=DXSDK_DIR=C:\Program Files (x86)\Microsoft DirectX SDK (February 2010)\
envp[8]=FP_NO_HOST_CHECK=NO
envp[9]=HOMEDRIVE=C:
envp[10]=HOMEPATH=\Users\Raymond
envp[11]=LOCALAPPDATA=C:\Users\Raymond\AppData\Local
envp[12]=LOGONSERVER=\\LUMIERE
envp[13]=NUMBER_OF_PROCESSORS=4
envp[14]=OS=Windows_NT
envp[15]=PATHEXT=.COM;.EXE;.BAT;.CMD;.VBS;.VBE;.JS;.JSE;.WSF;.WSH;.MSC
envp[16]=PROCESSOR_ARCHITECTURE=x86
envp[17]=PROCESSOR_ARCHITEW6432=AMD64
envp[18]=PROCESSOR_IDENTIFIER=Intel64 Family 6 Model 23 Stepping 10, GenuineInte
l
envp[19]=PROCESSOR_LEVEL=6
envp[20]=PROCESSOR_REVISION=170a
envp[21]=ProgramData=C:\ProgramData
envp[22]=ProgramFiles=C:\Program Files (x86)
envp[23]=ProgramFiles(x86)=C:\Program Files (x86)
envp[24]=ProgramW6432=C:\Program Files
envp[25]=PSModulePath=C:\Windows\system32\WindowsPowerShell\v1.0\Modules\
envp[26]=PUBLIC=C:\Users\Public
envp[27]=SESSIONNAME=Console
envp[28]=SystemDrive=C:
envp[29]=SystemRoot=C:\Windows
envp[30]=TEMP=C:\Users\Raymond\AppData\Local\Temp
envp[31]=TMP=C:\Users\Raymond\AppData\Local\Temp
envp[32]=USERDOMAIN=lumiere
envp[33]=USERNAME=Raymond
envp[34]=USERPROFILE=C:\Users\Raymond
envp[35]=VBOX_INSTALL_PATH=C:\Program Files\Oracle\VirtualBox\
envp[36]=VS80COMNTOOLS=C:\Program Files (x86)\Microsoft Visual Studio 8\Common7\
Tools\
envp[37]=WecVersionForRosebud.510=2
envp[38]=windir=C:\Windows
envp[39]=_ACP_ATLPROV=C:\Program Files (x86)\Microsoft Visual Studio 8\VC\Bin\AT
LProv.dll
envp[40]=_ACP_INCLUDE=C:\Program Files (x86)\Microsoft DirectX SDK (February 201
0)\Include;C:\Program Files\boost\boost_1_44_0;C:\Program Files\Microsoft SDKs\W
indows\v7.0\Include;C:\Program Files (x86)\Microsoft Visual Studio 8\VC\include;
C:\Program Files (x86)\Microsoft Visual Studio 8\VC\atlmfc\include;C:\Program Fi
les (x86)\Microsoft Visual Studio 8\VC\PlatformSDK\include;C:\Program Files (x86
)\Microsoft Visual Studio 8\SDK\v2.0\include
envp[41]=_ACP_LIB=C:\Program Files (x86)\Microsoft DirectX SDK (February 2010)\L
ib\x86;C:\Program Files\boost\boost_1_44_0\stage\lib;C:\Program Files\Microsoft
SDKs\Windows\v7.0\Lib;C:\Program Files (x86)\Microsoft Visual Studio 8\VC\lib;C:
\Program Files (x86)\Microsoft Visual Studio 8\VC\atlmfc\lib;C:\Program Files (x
86)\Microsoft Visual Studio 8\VC\atlmfc\lib\i386;C:\Program Files (x86)\Microsof
t Visual Studio 8\VC\PlatformSDK\lib;C:\Program Files (x86)\Microsoft Visual Stu
dio 8\SDK\v2.0\lib;C:\Program Files (x86)\Microsoft Visual Studio 8\;C:\Program
Files (x86)\Microsoft Visual Studio 8\lib
envp[42]=_ACP_PATH=C:\Program Files (x86)\Microsoft DirectX SDK (February 2010)\
Utilities\Bin\x86;C:\Program Files (x86)\Microsoft Visual Studio 8\VC\bin;C:\Pro
gram Files (x86)\Microsoft Visual Studio 8\VC\PlatformSDK\bin;C:\Program Files (
x86)\Microsoft Visual Studio 8\Common7\Tools\bin;C:\Program Files (x86)\Microsof
t Visual Studio 8\Common7\tools;C:\Program Files (x86)\Microsoft Visual Studio 8
\Common7\ide;C:\Program Files (x86)\HTML Help Workshop;C:\Program Files (x86)\Mi
crosoft Visual Studio 8\SDK\v2.0\bin;C:\Windows\Microsoft.NET\Framework\v2.0.507
27;C:\Program Files (x86)\Microsoft Visual Studio 8\;C:\Program Files (x86)\Micr
osoft Visual Studio 8\\SDK\v2.0\bin;C:\Windows\SysWow64;;C:\Program Files (x86)\
Windows Resource Kits\Tools\;C:\Windows\system32;C:\Windows;C:\Windows\System32\
Wbem;C:\Windows\System32\WindowsPowerShell\v1.0\;C:\Program Files\TortoiseSVN\bi
n;c:\GnuWin32\bin
envp[43]=PATH=C:\Program Files (x86)\Windows Resource Kits\Tools\;C:\Windows\sys
tem32;C:\Windows;C:\Windows\System32\Wbem;C:\Windows\System32\WindowsPowerShell\
v1.0\;C:\Program Files\TortoiseSVN\bin;c:\GnuWin32\bin;C:\Program Files (x86)\Mi
crosoft Visual Studio 8\;C:\Program Files (x86)\Microsoft Visual Studio 8\VC\bin

En ce qui concerne ta 2eme question

2°) j'ai cru comprendre que l'on pouvais rentrer des arguments avec code block à notre main en faisant:

(barre des menus) ==> project ==> Set arguments...

==> à quoi cela sert il ?

Justement, cela sert à passer des arguments (argc et argv) à la fonction main().

[membreComplexe12]

merci pour cette reponse tres detaillée.

j'ai quand meme pas compris un truc, quand peut on avoir besoin de donner des parametres aux main?

==> pour moi je main est juste l'endroit on je fais run et où je lance plein de fonction et tous les programmes que j'ai vu sont similaire: on lance le programme principal qui lui lance des fonctions qui ont besoins d'arguments.

Par contre si le main à des arguments ca veut dire que ce n'est pas lui le programme principal puisqu'il a besoin d'un programme superieur qui doit lui donner des arguments??

[Flob90]

@ram-0000: La 3° formes n'est pas standard (non données dans la section 3.6.1 en tout cas). Seules les deux premières sont celles qui doivent absolument compiler si le compilateur respecte le standard, ensuite il est laissé à la liberté du compilo d'accepter d'autre formes mais ce n'est plus standard (et donc portable).

@OP: Comme l'a dit ram-0000, c'est un tableau qui contient les arguments passé au programmes lors de son appel. Par exemple si mon programme s'appelle MonExec, alors lorsque je fais "MonExec truc1 truc2" dans une console, alors les arguments du main seront 3 et un tableau de chaines de carctère c contenant "MonExec" "truc1" "truc2" et 0. Je te laisse relire la réponse de ram-0000 pour les détails sur le premier élément du tableau.

[Goten]

merci pour cette reponse tres detaillée.

j'ai quand meme pas compris un truc, quand peut on avoir besoin de donner des parametres aux main?

==> pour moi je main est juste l'endroit on je fais run et où je lance plein de fonction et tous les programmes que j'ai vu sont similaire: on lance le programme principal qui lui lance des fonctions qui ont besoins d'arguments.

Par contre si le main à des arguments ca veut dire que ce n'est pas lui le programme principal puisqu'il a besoin d'un programme superieur qui doit lui donner des arguments??

T'as jamais fait un vim foo.c ou encore un cat xx ? bah foo.c et xx sont récupéré par les arguments de la fonction main..

[ram-0000]

@ram-0000: La 3° formes n'est pas standard (non données dans la section 3.6.1 en tout cas).

C'est vrai que habituel ne veut pas forcément dire standard , ceci dit, je viens de relire mon post et je ne parle pas de standard, je parle de forme.

[membreComplexe12]

"MonExec truc1 truc2" dans une console, alors les arguments du main seront 3 et un tableau de chaines de carctère c contenant "MonExec" "truc1" "truc2" et 0. Je te laisse relire la réponse de ram-0000 pour les détails sur le premier élément du tableau.

Ok, donc ca sert que si je veux lancer mon programme main.c à partir d'une console et que l'on a besoin de donner des arguments au main.c

(d'ailleurs on peut compiler un main.c à partir d'une console? comment on fait?)

T'as jamais fait un vim foo.c ou encore un cat xx ? bah foo.c et xx sont récupéré par les arguments de la fonction main..

mdrrr c'est du chinois pour moi

[ram-0000]

Par contre si le main à des arguments ca veut dire que ce n'est pas lui le programme principal puisqu'il a besoin d'un programme superieur qui doit lui donner des arguments??

Exactement, le main() à toujours un programme appelant (tu l'appelles supérieur si tu veux), c'est le loader du programme.

C'est un petit bout de l'OS qui est chargé d'attribuer une pile et de l'espace mémoire au process plus tout un tas d'autres bricoles (création des flux stdin, stdout, stderr) qui ne concernent que l'OS. Et au bout du compte, ce loader va appeler la fonction main().

[membreComplexe12]

Exactement, le main() à toujours un programme appelant (tu l'appelles supérieur si tu veux), c'est le loader du programme.

C'est un petit bout de l'OS qui est chargé d'attribuer une pile et de l'espace mémoire au process plus tout un tas d'autres bricoles (création des flux stdin, stdout, stderr) qui ne concernent que l'OS. Et au bout du compte, ce loader va appeler la fonction main().

merci, et concernant le lancement de programme (main.c) on peut le faire à partir d'une console? comment?

[gl]

Ok, donc ca sert que si je veux lancer mon programme main.c à partir d'une console et que l'on a besoin de donner des arguments au main.c

Non, cela sert si tu veux/dois fournir des paramètres à un programme.

Ce n'est pas restreint à la console et tu ne les fournies pas à main.c ou que sais-je mais au programme compilé.

c'est du chinois pour moi

N'as-tu jamais appelé un programme en ligne de commande avec des paramètres ?
C'est aussi ce mécanisme qui permet lorsque tu double-cliques sur un fichier de données dans ton explorateur de lancer le programme qui lui est lié et d'ouvrir le fichier sélectionner (le nom du fichier est fourni en argument au programme).

[Steph_ng8]

Salut !
Ouvre une console/un terminal, pour essayer.
Je vais supposer que tu es sous Windows, alors : « Menu Démarrer » > « Accessoires » > « Invite de commandes ».

Ensuite, tape le chemin vers l'exécutable de ton navigateur, puis appuie sur « Entrée ».
Tu peux le trouver en faisant un clic droit sur le raccourci correspondant dans le Menu Démarrer (onglet « Raccourci », champ « Cible » ; les guillemets sont importants si le chemin contient des espaces).
Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
"C:\Program Files\Internet Explorer\iexplore"
"C:\Program Files\Mozilla Firefox\firefox"
C:\chemin\vers\mon\navigateuramoi
etc.

Normalement, ton navigateur se lance sur la page d'accueil.

Ferme le navigateur et recommence, mais cette fois en ajoutant l'adresse d'un site, par exemple « www.developpez.net ».

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
"C:\Program Files\Internet Explorer\iexplore" www.developpez.net
"C:\Program Files\Mozilla Firefox\firefox" www.developpez.net
C:\chemin\vers\mon\navigateuramoi www.developpez.net
etc.

Cette fois, ton navigateur devrait directement afficher le site en question.

Que s'est-il passé ?
Rien de bien compliqué.

Dans le premier cas, on peut dire que l'on a eu ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
argc = 1
argv[0] = "chemin\vers\ton\navigateuratoi" // Selon le programme que tu as appelé
argv[1] = NULL

Le programme regarde les paramètres qu'on lui a passé, et se rend compte qu'il n'y en a pas (à part le nom de l'exécutable lui-même).
Alors il adopte le comportement par défaut (afficher la page d'accueil).

Dans le second cas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
argc = 2
argv[0] = "chemin\vers\ton\navigateuratoi"
argv[1] = "www.developpez.net"
argv[2] = NULL

Cette fois, il y a un paramètre, et c'est une adresse Web.
Alors il tente d'afficher la page en question.

Tu peux t'amuser à mettre plusieurs site en paramètres, et normalement ton navigateur devrait tous les ouvrir.
Soit dans une fenêtre et plusieurs onglets, soit dans plusieurs fenêtres.

On peut passer d'autres types de paramètres, comme des options par exemple (démarrer en mode de débogage, démarrer sans les modules complémentaires, etc.), mais je ne connais pas la liste...

Voilà pour le principe de argc (ARGument Count) et argv (ARGument Values).

[Steph_ng8]

(d'ailleurs on peut compiler un main.c à partir d'une console? comment on fait?)

Bien sûr !
On peut tout faire à partir d'une console !
D'ailleurs, à chaque fois que tu lances un programme, soit via un raccourci, soit en cliquant directement sur l'exécutable, tu exécutes une commande sans le savoir !
Ou quand tu ouvres un fichier, comme l'a fait remarquer gl.

C'est pareil lorsque tu copies ou déplaces des fichiers/dossiers, quand tu renommes, supprimes, crées...
Absolument tout est fait en lignes de commandes, l'interface graphique sert simplement à faciliter la tâche aux utilisateurs.

Pour en revenir à la compilation en lignes de commande, il te suffit d'appeler le compilateur avec les options adéquates.
Lorsque l'on utilise un EDI (Environnement de Développement Intégré), il e charge pour nous de le faire.
Il a des options par défaut que l'on peut changer (chemin vers le compilateur, options à passer au compilateur, etc.).
Personnellement, je n'utilise pas CodeBlocks, donc je ne sais pas quel compilateur il utilise.

Alors on va supposer que l'on utilise le compilateur GCC, et que le chemin de l'exécutable est : « C:\MinGW\bin\gcc.exe ».
Pour compiler un fichier seul, on peut lancer la commande, si on se trouve dans le même dossier que le fichier source « main.c » :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

C:\MinGW\bin\gcc -Wall -o monpremierexecutable main.c

(L'extension « .exe » n'est pas obligatoire)
Je ne vais pas entrer dans les détails, mais sache que le compilateur va générer un fichier exécutable « monpremierexecutable.exe », et affichera un maximum d'erreurs et d'avertissements (de compilation).

Si on veut s'amuser à décortiquer les paramètres…

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
argc = 5
argv[0] = "C:\MinGW\bin\gcc.exe"
argv[1] = "-Wall"
argv[2] = "-o"
argv[3] = "monpremierexecutable"
argv[4] = "main.c"
argv[5] = NULL

Si on a besoin de compiler plusieurs fichiers sources :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
C:\MinGW\bin\gcc -Wall -c -o fichier1.o fichier1.c
C:\MinGW\bin\gcc -Wall -c -o fichier2.o fichier2.c
...
C:\MinGW\bin\gcc -Wall -c -o main.o main.c
C:\MinGW\bin\gcc -Wall -o unautreexecutable fichier1.o fichier2.o ... main.o

Bon, on peut se passer d'indiquer à chaque fois le chemin complet, mais pour ça il faut faire une manipulation particulière…

Si tu souhaites plus de détails sur les deux exemples, n'hésite pas à demander.
Sinon, pour plus d'infos sur la compilation, tu peux déjà aller voir ici.

[koala01]

Salut,
Il faut comprendre que, à la base, main.c est un fichier dont le contenu ne veut strictement rien dire pour l'ordinateur: c'est une succession d'octets qui sera utilisée par un autre programme (par exemple code::blocks) qui, lui, saura comment il doit le traiter.

Code::blocks devra, quand à lui, le traiter essentiellement de trois manières:

• en affichant le contenu de manière lisible par toi (avec l'indentation, la coloration syntaxique et tout le saint frusquin)
• en te permettant de le modifier
• en demandant à un compilateur (et à d'autres outils apparentés) de le traiter pour créer une application exécutable.

Accessoirement (enfin, c'est quand même une des actions qu'on lui demande souvent d'exécuter), code::blocks est capable, une fois que le compilateur a fini son travail, de lancer automatiquement l'application exécutable fraichement créée.

Lorsque tu définis des argument dans le menu project==>set arguments, tu indiques simplement à code::blocks qu'il devra lancer l'application en lui passant les arguments indiqués.

Cela aura strictement le même résultat que si tu utilisait la ligne de commande (menu démarrer->accessoire->invite de commandes) et que tu lançais ton application sous la forme de application.exe argument1 argument2 ...

Maintenant, si la question est simplement "pourquoi passer des arguments à l'application " la réponse est tout aussi simple: "parce que cela peut être intéressant"

Imaginons la commande dir, qui fait afficher le contenu du répertoire courent sous windows.

On n'en a pas forcément conscience, mais il est fort probable que cette commande soit en réalité... une application qui a été, à la base, écrite en C (ou en un quelconque autre langage), dont le code source contenait, entre autres, une fonction main sous la forme de int main(int argc, char *argv[]).

La raison pour laquelle je me permet cette affirmation est, tout simplement, le fait que cette instruction accepte une série d'arguments qui permettent d'en modifier le comportement:

• dir /? aura pour résultat de provoquer l'affichage des explication de l'ensemble des arguments que tu peux passer à dir
• dir /B fera que dir n'affiche que le nom des fichiers ou de dossier (sans autre information)
• dir /D fera que les noms de fichiers et de dossiers seront affichés sur cinq colonnes
• ... je ne vais pas reprendre l'ensemble des arguments possibles

On peut donc avoir la quasi certitude que, non seulement, la fonction principale prenait la forme de int main(int argc, char *argv[]), mais, en plus, qu'elle était en grande partie composée par des instructions permettant de traiter ces arguments et par une batterie de tests permettant de déterminer un comportement particulier en fonction des arguments récupérés.

Et bien sur, j'ai pris ici l'exemple de dir, mais il en va évidemment de même pour n'importe quelle autre instruction "classique" de la ligne de commande ou pour n'importe quelle application de ton cru:

Si tu estimes utile de fournir des arguments à l'application que tu crées, tu devra fatalement passer par l'utilisation de cette signature particulière pour ta fonction main

Maintenant, si tu ne veux pas, ou que tu n'estimes pas nécessaire de permettre à ton application de recevoir des arguments au moment de son lancement, tu peux, parfaitement, utiliser l'autre signature qui ne prend aucun argument: int main().

Tu peux aussi (quoi que ce serait sans doute dommage ) décider de ne simplement pas tenir compte des arguments qui seront passés à ton application

[membreComplexe12]

merci beaucoup je pense qu'a present j'ai bien saisi l'utilisation de ces arguments.

c'est tres gentil d'avoir pris le temps de m'expliquer

[Emmanuel Deloget]

Moi, pédant, souhaite revenir sur le prototype de main.

Selon la norme C++, ce prototype est :

int main()

ou

int main(int ac, const char* av[]) (et non pas char**)

A ceci s'ajoute que toute implémentation est autorisée à ajouter un nombre quelconque de paramètres, de type quelconque. Par exemple, le classique

int main(int ac, const char* av[], const char* env[])

ou env est la liste des variables d'environnement.

Voilà. Pédant retourne au loin, sur son canari bai.