Doublons possibles:
Quels sont les arguments de main () pour?
Qu'est-ce que int argc, char * argv [] signifie?
Chaque programme commence par la définition main(int argc, char *argv[])
.
Je ne comprends pas ce que cela signifie. Je serais très heureux si quelqu'un pouvait expliquer pourquoi nous utilisons ces arguments si nous ne les utilisons pas dans le programme? Pourquoi ne pas simplement: int main()
?
Le nom du programme est-il l'un des éléments de *argv[]
et argc
est-il le compte du nombre d'arguments dans *argv[]
? Quels sont les autres arguments envoyés à *argv[]
? Comment pouvons-nous les envoyer?
Les arguments argc
et argv
de main
sont utilisés pour envoyer des arguments à un programme. Le moyen le plus familier est probablement d'utiliser le bon vieux terminal où un utilisateur peut taper cat file
. Ici, le mot cat
est un programme qui prend un fichier et le sort sur une sortie standard (stdout
).
Le programme reçoit le nombre d’arguments dans argc
et le vecteur d’arguments dans argv
, en haut l’argument arg ument c nombre serait deux (le nom du programme compte comme premier argument) et le arg valeur v ector devrait contenir [cat
, file
, null ]. Bien que le dernier élément soit un pointeur nul.
Généralement, vous l'écrivez comme ceci:
int // Specifies that type of variable the function returns.
// main() must return an integer
main ( int argc, char **argv ) {
// code
return 0; // Indicates that everything went well.
}
Si votre programme ne nécessite aucun argument, il est également valide d'écrire une fonction main
- de la manière suivante:
int main() {
// code
return 0; // Zero indicates success, while any
// Non-Zero value indicates a failure/error
}
Dans les premières versions du langage C, il n'y avait pas int
avant main
car cela était implicite. Aujourd'hui, cela est considéré comme une erreur.
Sur POSIX - systèmes compatibles (et Windows), il est possible d’utiliser un troisième paramètre char **envp
qui contient un vecteur du programmes env variables de repassage . Il existe d'autres variantes de la liste d'arguments de la fonction main
, mais je ne la détaillerai pas ici car elle n'est pas standard.
En outre, la dénomination des variables est une convention et n'a pas de signification réelle. C’est toujours une bonne idée d’adhérer à cela afin de ne pas confondre les autres, mais il serait également valable de définir main
comme
int main(int c, char **v, char **e) {
// code
return 0;
}
Et pour votre deuxième question, il existe plusieurs façons d’envoyer des arguments à un programme. Je vous recommande de regarder _ [exec*()
famille de fonctions qui est POSIX - standard, mais est probablement plus facile d'utiliser simplement system
("command arg1 arg2")
, mais l'utilisation de system()
est généralement mal vue. sur comme il n'est pas garanti de fonctionner sur tous les systèmes. Je ne l'ai pas testé moi-même; mais s'il n'y a aucun bash
, zsh
ou autre shell installé sur un système * NIX, system()
échouera.
Celles-ci permettent de transmettre des arguments à votre programme, par exemple à partir de la ligne de commande, lorsqu'un programme est appelé
$ gcc mysort.c -o mysort
$ mysort 2 8 9 1 4 5
Ci-dessus, le programme mysort
est exécuté avec certains paramètres de ligne de commande. Dans main( int argc, char * argv[])
, cela se traduirait par
Argument Count, argc = 7
puisqu'il y a 7 arguments (en comptant le programme), et
Argument Vector, argv[] = { "mysort", "2", "8", "9", "1", "4", "5" };
Voici un exemple complet.
$ cat mysort.c
#include <stdio.h>
int main( int argc, char * argv [] ) {
printf( "argc = %d\n", argc );
for( int i = 0; i < argc; ++i ) {
printf( "argv[ %d ] = %s\n", i, argv[ i ] );
}
}
$ gcc mysort.c -o mysort
$ ./mysort 2 8 9 1 4 5
argc = 7
argv[ 0 ] = ./mysort
argv[ 1 ] = 2
argv[ 2 ] = 8
argv[ 3 ] = 9
argv[ 4 ] = 1
argv[ 5 ] = 4
argv[ 6 ] = 5
[Les chaînes char
"2", "8" etc. peuvent être converties en nombre en utilisant une fonction de conversion de caractère en nombre, par ex. atol()
(lien )]
Avec argc
(nombre d'arguments) et argv
(vecteur d'arguments), vous pouvez obtenir le nombre et les valeurs des arguments transmis lorsque votre application a été lancée.
De cette façon, vous pouvez utiliser des paramètres (tels que -version
) lorsque votre application est lancée pour agir différemment.
Mais vous pouvez aussi utiliser int main(void)
comme prototype en C.
Il existe un troisième prototype (moins connu et non standard) avec un troisième argument qui est envp
. Il contient des variables d'environnement.
Ressources:
argc
signifie le nombre d'arguments transmis au programme. char* argv[]
sont les arguments passés. argv[0]
est toujours le nom du programme lui-même. Je ne suis pas sûr à 100%, mais je pense que int main()
est valide en C/C++.
argc
est le nombre d'arguments de ligne de commande fournis au programme à l'exécution, et argv
est un tableau de tableaux de caractères (plutôt un tableau de chaînes C) contenant ces arguments. Si vous savez que vous n'aurez pas besoin des arguments de ligne de commande, vous pouvez déclarer votre principal en prenant un argument void
, à la place:
int main(void) {
/* ... */
}
Ce sont les deux seuls prototypes définis pour main
conformément aux normes, mais certains compilateurs autorisent également un type de retour de void
. Plus sur ceci sur Wikipedia .
argc
est le nombre d'arguments de ligne de commande et argv
est un tableau de chaînes représentant des arguments de ligne de commande.
Cela vous donne la possibilité de réagir aux arguments transmis au programme. Si vous n'en attendez aucun, vous pouvez également utiliser int main
.
Vous pouvez exécuter votre application avec des paramètres tels que app -something -somethingelse
. int argc
représente le nombre de ces paramètres et char *argv[]
est un tableau contenant les paramètres réels transmis à votre application. De cette façon, vous pouvez travailler avec eux dans votre application.