Concernant " main (int argc, char * argv[])" [duplicate]
duplicata possibles:
Quels sont les arguments pour main ()?
que signifie int argc, char * argv []?
chaque programme commence par la définition main(int argc, char *argv[]) .
Je ne comprends pas ce que ça veut dire. 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 pas: int main() ?
Est le nom du programme l'un des éléments de *argv[] et argc est le comptage du nombre d'arguments dans *argv[] ? Quels sont les autres arguments envoyés à *argv[] ? Comment pouvons-nous envoyer?
8 réponses
les arguments argc et argv de main est utilisé comme un moyen d'envoyer des arguments à un programme, le moyen probablement le plus familier est d'utiliser le bon vieux terminal où un utilisateur pourrait taper cat file . Ici, le mot cat est un programme qui prend un fichier et le produit à la sortie standard ( stdout ).
le programme reçoit Le nombre d'arguments dans argc et le vecteur d'arguments dans argv , dans le ci-dessus le arg ument c ount serait deux (le nom du programme compte comme premier argument) et le arg ument v ector contiendrait [ cat , file , null ]. Alors que le dernier élément étant un pointeur nul.
habituellement, vous l'écririez 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 pas d'arguments, il est également valide d'écrire une main - fonction de la façon suivante:
int main() {
// code
return 0; // Zero indicates success, while any
// Non-Zero value indicates a failure/error
}
dans les premières versions de la langue C, il n'y avait pas de int avant main comme cela était implicite. Aujourd'hui, c'est considéré comme une erreur.
sur POSIX systèmes compatibles (et Windows), il existe la possibilité d'utiliser un troisième paramètre char **envp qui contient un vecteur des programmes env gée variables . D'autres variantes de la liste d'arguments de la fonction main existent, mais je ne vais pas le détailler ici car il n'est pas standard.
aussi, le nom des variables est un convention et n'a pas de sens réel. C'est toujours une bonne idée d'adhérer à ce que vous ne confondez pas les autres, mais il serait tout aussi valable pour définir main comme
int main(int c, char **v, char **e) {
// code
return 0;
}
Et pour votre deuxième question, il y a plusieurs façons d'envoyer des arguments à un programme. Je vous recommande de regarder le exec*() famille de fonctions qui est POSIX - standard, mais il est probablement plus facile à utiliser system ("command arg1 arg2") , mais l'utilisation de system() est généralement mal vue car il n'est pas garanti pour fonctionner sur tous les systèmes. Je ne l'ai pas testé moi-même; mais s'il n'y a pas de bash , zsh , ou autre shell installé sur un système *NIX, system() va échouer.
ceux-ci sont pour passer des arguments à votre programme, par exemple à partir de la ligne de commande, quand un programme est invoqué
$ gcc mysort.c -o mysort
$ mysort 2 8 9 1 4 5
ci-dessus, le programme mysort est exécuté avec quelques paramètres de ligne de commande. À l'intérieur de main( int argc, char * argv[]) , ce qui entraînerait des
Argument Count, argc = 7
puisqu'il y a 7 arguments (compter le programme), et
Argument Vector, argv[] = { "mysort", "2", "8", "9", "1", "4", "5" };
en 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
[Le char chaînes "2", "8", etc. peut être converti en nombre en utilisant une fonction de conversion de caractère en nombre, p.ex. atol() (lien )]
avec argc (argument count) et argv (argument vector) vous pouvez obtenir le nombre et les valeurs des arguments passés 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 d'une manière différente.
mais vous pouvez aussi utiliser int main(void) comme prototype en C.
il y a 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 passés 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++.
Le comp.lang.C FAQ traite de la question
"What's the correct declaration of main()?"dans Question 11.12 a .
argc est le nombre d'arguments en ligne de commande et argv est un tableau de chaînes représentant les arguments en ligne de commande.
Cela vous donne la possibilité de réagir aux arguments passés au programme. Si vous n'en attendez aucune, Vous pouvez aussi bien utiliser int main .
argc est le nombre d'arguments en ligne de commande donnés au programme à l'exécution, et argv est un tableau de tableaux de caractères (plutôt, un tableau de C-strings) contenant ces arguments. Si vous savez que vous n'allez pas avoir besoin des arguments en ligne de commande, vous pouvez déclarer votre main à prendre un argument void , à la place:
int main(void) {
/* ... */
}
ce sont les deux seuls prototypes définis pour main , selon les normes, mais certains compilateurs autoriser un type de retour de void ainsi. Plus sur ce sur Wikipedia .
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 avec les paramètres réels étant passés dans votre application. De cette façon, vous pouvez travailler avec eux à l'intérieur de votre application.