Comment transférer des arguments dans la principale C. Plusieurs détails sur la fonction principale. La valeur pratique du transfert de données au programme

Arguments facultatifs et nommés

Arguments facultatifs

Dans la version C # 4.0, un nouvel outil améliore la commodité de spécifier des arguments lors de l'appel d'une méthode. Cet outil s'appelle arguments facultatifs Et vous permet de déterminer la valeur par défaut du paramètre de méthode. Cette valeur Il sera utilisé par défaut si l'argument correspondant n'est pas spécifié pour le paramètre lorsque la méthode est appelée. Par conséquent, spécifiez l'argument d'un tel paramètre n'est pas nécessaire. Les arguments facultatifs vous permettent de simplifier l'appel aux méthodes où les arguments par défaut sont appliqués à certains paramètres. Ils peuvent également être utilisés comme une forme "abrégée" de méthodes de surcharge.

Le principal stimulus d'ajouter des arguments facultatifs était la nécessité de simplifier l'interaction avec les installations COM. Dans plusieurs modèles d'objet Microsoft (par exemple, Microsoft Office), la fonctionnalité est fournie sur les installations COM, dont beaucoup ont été écrites il y a longtemps et sont conçues pour utiliser des paramètres facultatifs.

Un exemple d'utilisation des arguments facultatifs est indiqué ci-dessous:

Utiliser le système; en utilisant System.Collections.Genic; En utilisant system.linq; En utilisant system.text; Espace de noms ConsoleApplication1 (programme de classe (// arguments B et avec précisez en appelant éventuellement appelé statique int mysum (int A, int b \u003d 5, int C \u003d 10) (retour A + B + C;) Void statique principal () (Int Sum1 \u003d mysum (3); int Sum2 \u003d mysum (3,12); console.writeline ("Sum1 \u003d" + Sum1); console.write ("Sum2 \u003d" + Sum2); console.readline ();))

Il convient de garder à l'esprit que tous les arguments facultatifs doivent certainement être indiqués au droit d'obligation. Outre les méthodes, des arguments facultatifs peuvent être utilisés dans des concepteurs, des indexeurs et des délégués.

L'avantage des arguments facultatifs est notamment dans le fait qu'ils simplifient le traitement de la programmation avec des défis complexes des méthodes et des constructeurs. En effet, souvent dans la méthode, vous devez définir plus de paramètres que d'habitude. Et dans de tels cas, certains de ces paramètres peuvent être facultatifs en raison de l'utilisation précise des arguments facultatifs. Cela signifie que seuls les arguments qui sont importants dans ce cas particulier sont nécessaires, et tous les arguments ne doivent pas être obligatoires. Cette approche nous permet de rationaliser la méthode et de simplifier l'attrait de la programmation.

Arguments nommés

Un de plus fonctionnalitéqui a été ajouté à C # avec la version de sortie de la version 4.0, est le support de la soi-disant arguments nommés (arguments nommés). Comme on le sait, lors du transfert d'arguments, la procédure de leur suivante, en règle générale, devrait coïncider avec cet ordre dans lequel les paramètres sont définis dans la méthode elle-même. En d'autres termes, la valeur de l'argument est attribuée au paramètre par sa position dans la liste des arguments.

Cette restriction est conçue pour surmonter les arguments nommés. L'argument nommé vous permet de spécifier le nom du paramètre auquel sa valeur est attribuée. Et dans ce cas, l'ordre des arguments ne compte plus. Ainsi, nommés arguments dans une certaine mesure similaires à ceux mentionnés précédemment des initialistes d'objets, bien qu'ils diffèrent d'eux avec leur syntaxe. Pour spécifier l'argument de nom, le prochain mode de syntaxe est utilisé:

nom du paramètre: valeur

Ici le nom du paramètre Indique le nom du paramètre auquel la valeur est passée. Bien sûr, le nom de paramètre doit signifier le nom du paramètre valide pour la méthode appelée.

Mots clés: Paramètres ligne de commande

Paramètres de ligne de commande

C et - langue compilée. Après assemblage, le programme est un fichier exécutable (nous ne considérons pas la création de bibliothèques dynamiques, de pilotes, etc.). Nos programmes sont très simples et ne contiennent pas de bibliothèques d'exécution (bibliothèques d'exécution). Ils peuvent donc être transférés sur un ordinateur avec le même système d'exploitation (et l'architecture similaire) et y allient.

Le programme lors du démarrage peut prendre des paramètres. Ce sont les arguments de la fonction principale. Vue générale de la fonction principale suivant

Vide principal (int argc, char ** argv) (...)

Le premier argument Argc est le nombre de fonctions de paramètre transmis. Le deuxième argument est un tableau de chaînes - les paramètres eux-mêmes sont en fait. Étant donné que les paramètres de la fonction peuvent être tout, ils sont transmis comme des chaînes et le programme lui-même doit démonter et conduire au type souhaité.

Le premier argument (ARGV) est toujours le nom du programme. Dans ce cas, le nom est affiché en fonction de l'exécution du programme.

#Inclure. #Inclure. Vide principal (int Argc, char * ** argv) (printf ("% s", argv);)

Maintenant, apprenez à travailler un peu avec la ligne de commande. Il sera nécessaire pour transmettre les arguments à notre programme. La combinaison des touches WIN + R appelle la fenêtre "Exécution". Tapez CMD en elle et vous ouvrirez la ligne de commande. Vous pouvez également trouver la recherche CMD.EXE dans le menu Démarrer. Dans Unix-liked systèmes d'exploitationoh, vous pouvez appeler le programme "terminal".

Nous n'étudierons aucune équipe. Seuls ceux qui seront nécessaires dans le travail.

Standard pour tous les systèmes d'exploitation, la commande CD transition vers le dossier souhaité. Il y a deux noms réservés -. (Point) et .. (deux points). Le point est le nom du dossier actuel.

Ne va nulle part

Appel au dossier parent

Transition vers le dossier parent

Pour la transition vers l'adresse du CD souhaitée est écrite. Par exemple, vous devez aller à Windows dans le dossier C: \\ Windows \\ System32

CD C: \\ Windows \\ System32

Sous Linux si vous devez aller au dossier / var / mysql

CD / var / mysql

Si le chemin contient des espaces, il est écrit en guillemets doubles

CD "D: \\ Docunts et Paramètres \\ prolog"

Le terminal dispose des fonctionnalités utiles suivantes: Si vous appuyez sur la flèche Haut, la commande précédente exécutée apparaît. Si vous appuyez sur l'onglet, le terminal essaiera d'ajouter une chaîne à la commande, ou d'ajouter le chemin d'accès, de l'épartant à tous les dossiers et aux fichiers du dossier en cours.
CD C: \\ \\
Appuyez sur TAB et voyez ce qui se passe.

Une autre commande d'AIR importante sur Windows et LS sous Linux, affiche le contenu du dossier actuel sur la console (le dossier dans lequel vous êtes actuellement).

Votre programme a renvoyé votre nom complet. Accédez au dossier où votre programme est situé et de voir son contenu.

Maintenant, après la sortie de notre dossier, vous pouvez effectuer notre programme. Pour ce faire, tapez son nom.

NOTE - Le nom a changé. Étant donné que le programme est appelé à partir de son dossier, il est affiché par rapport au nom. Maintenant, vous modifierez le programme et apporterez-le sous toutes les arguments. qui sont transférés vers elle.

#Inclure. #Inclure. Vide principal (int argc, char ** argv) (int i; pour (i \u003d 0; i< argc; i++) { printf("%s\n", argv[i]); } }

Recueillir le projet. Avant l'assemblage, assurez-vous que le programme est fermé. Appelez maintenant le programme en faisant passer des arguments différents. Pour ce faire, écrivez le nom du programme et dans l'espace d'argument.

Nous écrivons maintenant un programme qui reçoit deux arguments du nombre et affiche sa somme.

#Inclure. #Inclure. #Inclure. Vide principal (int argc, char ** argv) (int A, b; si (argc! \u003d 3) (Printf ("Erreur: trouvé% d Argent. Besoin exactement 2", argc-1); sortie (1); ) A \u003d Atoi (ARGV); B \u003d ATOI (ARGV); Printf ("% D", A + B);)

Nous collectons et appelons

Ainsi, la plupart des programmes fonctionnent. Cliquez sur une étiquette, vous appelez le programme auquel il se réfère. La plupart des programmes prennent également divers arguments. Par exemple, vous pouvez appeler browser Firefox. De la ligne de commande et des arguments de transfert
Firefox.exe "www.mozilla.org" site "et ouvrira immédiatement les sites en deux onglets aux adresses spécifiées.

De nombreuses commandes standard ont également des paramètres. Il est accepté sous Windows qu'ils commencent par un look droit, à UNIX avec un moins ou deux minus. par example

Affiche uniquement les dossiers et dans le terminal Linux

LS -L affiche tous les fichiers et dossiers avec des attributs

Pour avoir visualisé commandes Windows Dial sur la ligne de commande d'aide ou voir le guide (il est facile de trouver sur Internet). Pour les équipes Linux et leurs options, bien plus encore et certaines d'entre elles sont des langages de programmation indépendants, il vaut donc la peine d'apprendre au moins un ensemble minimum et leurs options.

Lors de la création d'une application de console dans la langue de programmation C ++, une chaîne est automatiquement créée très similaire à celle-ci:

Int Main (int Argc, char * argv) // Paramètres de fonction principale ()

Cette chaîne est un en-tête fonction principale Main (), les paramètres de ARG et d'ARGV sont annoncés entre crochets. Donc, si vous exécutez le programme via la ligne de commande, il est possible de transférer toutes les informations à ce programme, pour cela, et d'exister des paramètres ArgC et ARGV. Le paramètre ArgC a un type de données INT et contient le nombre de paramètres transmis à la fonction principale. De plus, Argc est toujours au moins 1, même lorsque nous ne transmettrons aucune information, car le premier paramètre est le nom de la fonction. Le paramètre Argv est un tableau de pointeurs à cordes. À travers la ligne de commande, seul un type de chaîne peut être transmis. Les pointeurs et les lignes sont deux gros sujets créés des sections distinctes. Il est donc via le paramètre ARGV et toutes les informations sont transmises. Nous allons développer un programme que nous allons passer à travers la commande chaîne de Windowset transmettez-y quelques informations.

// argc_argv.cpp: détermine le point d'entrée de l'application de la console. #Include "stdafx.h" #include Utilisation de Namespace STD; Int Main (int Argc, char * argv) (si (argc\u003e<< argv<

// code de code :: blocs

// Code Dev-C ++

// argc_argv.cpp: détermine le point d'entrée de l'application de la console. #Inclure. Utilisation de Namespace STD; Int Main (int Argc, char * argv) (si (argc\u003e 1) // Si nous transmettons des arguments, l'ARGC sera supérieur à 1 (en fonction du nombre d'arguments) (COUT<< argv<

Après avoir timide le programme, ouvrez la ligne de commande de Windows et faites-la glisser dans la fenêtre de ligne de commande de notre programme dans la fenêtre de la ligne de commande, le chemin d'accès complet au programme sera affiché sur la ligne de commande (mais vous pouvez prescrire le chemin d'accès à Le programme manuel), alors vous pouvez cliquer sur ENTRER Et le programme commencera (voir la figure 1).

Figure 1 - Paramètres de la fonction principale

Depuis que nous venons de lancer le programme et que nous n'avons adopté aucun argument, le message n'est pas apparu. La figure 2 montre le début du même programme via la ligne de commande, mais déjà avec la transmission de l'argument ouvert.

Figure 2 - Paramètres de la fonction principale

L'argument est le mot ouvert, comme on peut le voir à partir de la figure, ce mot est apparu à l'écran. Vous pouvez transmettre plusieurs paramètres immédiatement, les séparer les uns avec les autres. Si vous devez transmettre le paramètre composé de plusieurs mots, ils doivent alors être pris en citations doubles, puis ces mots seront considérés comme un paramètre. Par exemple, la figure montre le lancement du programme, avec le transfert de l'argument composé de deux mots - ça marche.

Figure 3 - Paramètres de la fonction principale

Et si vous enlevez des citations. Je ne verrai que le mot. Si vous ne prévoyez pas de transmettre des informations lorsque vous démarrez le programme, vous pouvez supprimer des arguments dans la fonction principale (), vous pouvez également modifier les noms des arguments. Parfois, il existe une modification des paramètres ArgC et ARGV, mais tout dépend du type d'application créé ou de l'environnement de développement.

Avec la création automatisée d'une application de console dans la langue de programmation C ++, la fonction principale est automatiquement créée très similaire à celle-ci:

int Main (int Argc, char * argv)
{…}

L'en-tête de fonction contient la signature de la fonction principale principale () avec des arguments arguments et argv.
Si vous exécutez le programme via la ligne de commande, il est possible de transférer des informations à ce programme. Pour cela, il existe des arguments de la ligne de commande ArgC et Argv.
Le paramètre ArgC a un type INT et contient le nombre de paramètres transmis à la fonction principale. De plus, Argc est toujours au moins 1, même lorsque les fonctions principales ne sont transmises par aucune information, car le nom de l'application est considéré comme le premier paramètre.
Le paramètre Argv est un éventail de pointeurs vers des chaînes. À travers la ligne de commande, seul un type de chaîne peut être transmis.

Lorsque vous démarrez le programme via la ligne de commande Windows, vous pouvez transmettre des informations. Dans ce cas, la ligne de commande examinera:
DISQUE: \\ PATH \\ NAME.EXE Argument1 Argument2 ...

Les arguments de ligne de commande sont séparés par un ou plusieurs espaces.

L'argument ARGV contient le nom complet de l'application:

#Inclure.
utilisation de Namespace STD;

couton<< argv << endl;

Retour 0;
}

Résultat de l'exécution

Exemple: calculer le travail de deux entiers
Le programme utilise une fonction de conversion de chaîne sur un entier StrToint () à partir d'ici.

#Inclure.
utilisation de Namespace STD;
int strtoint (char * s) (...)
int Main (int spinc, char * argv) (

Int a \u003d 0, b \u003d 0;

Si (Argc\u003e 1)

a \u003d strtoint (argv);

Si (argc\u003e 2)

b \u003d strtoint (argv);

couton<< a <<«*» << b << «= « << a*b << endl;

Retour 0;
}

Démarrer le programme est effectué comme

Résultat de l'exécution

Débogage du programme avec arguments de ligne de commande

Pour transférer les arguments de la ligne de commande lors du débogage du programme, vous devez contacter le menu. Propriétés Projet.


Sur l'onglet Propriétés de configuration -\u003e Débogage choisir Équipe des arguments Et demander leurs valeurs.

Lorsque vous démarrez le programme en mode de débogage, les arguments entrés seront perçus par le programme comme arguments de ligne de commande.

Une fois intéressé, le contenu du processus principal du processus principal de Linux. Il a mené des enquêtes et maintenant je vous présente le résultat.

Fonction principale Description Options:
1. Int Main ()
2. INT MAIN (INT ARGC, CHAR ** ARGV)
3. INT MAIN (INT ARGC, CHAR ** ARGV, CHAR ** ENV)
4. INT MAIN (INT ARGC, CHAR ** ARGV, CHAR ** ENV, ELFW (AUXV_T) AUXV)
5. Int Main (int Argc, Char ** argv, Char ** env, Char ** Apple)

Argc - Nombre de paramètres
Argv - réseau zéro-terminal de pointeurs sur les chaînes de paramètres de ligne de commande
Env - Gamme zéro-terminal de pointeurs aux lignes de variables d'environnement. Chaque ligne de nom de format \u003d valeur
Auxv - Array de valeur auxiliaire (disponible uniquement pour PowerPC)
Apple - chemin vers un fichier exécutable (à MacOS et Darwin)
Vecteur auxiliaire - une matrice avec diverses informations supplémentaires, telles qu'un ID utilisateur efficace, un signe d'un peu un peu, la taille de la page de la mémoire, etc.

La taille du segment de pile peut être examinée dans le fichier de cartes:
CAT / PROC / 10918 / Cartes
…
7FFFFFA3000-7FFFFFFF000 RW-P 00000000 00:00 0
…

Avant que le chargeur de démarrage ne soit contrôlé en main, il initialise le contenu des tableaux des paramètres de ligne de commande, des variables d'environnement, du vecteur auxiliaire.
Après l'initialisation, la partie supérieure de la pile ressemble à ceci pour la version 64 bits.
Adresse senior d'en haut.

1.	0x7FFFFFFF000.	Le point supérieur du segment de pile. Appel provoque SEGFAULT.
	0x7FFFFFFFF8F8.	NUL	annuler *	8	0x00 "
2.		Nom de fichier.	Carboniser.	1+	"/Tmp/a.out"
			Carboniser.	1	0x00
...
		env	Carboniser.	1	0x00
...
			Carboniser.	1	0x00
3.	0x7FFFFFFE5E0.	env	Carboniser.	1	..
			Carboniser.	1	0x00
...
		Argv.	Carboniser.	1	0x00
...
			Carboniser.	1	0x00
4.	0x7FFFFFFFE5BE.	Argv.	Carboniser.	1+	"/Tmp/a.out"
5.		Tableau de longueur aléatoire
6.		Données pour Auxv.	annuler *	48"
		AT_NULL.	Elf64_auxv_t.	16	{0,0}
...
		Auxv.	Elf64_auxv_t.	16
7.		auxv.	Elf64_auxv_t.	16	Ex.: (0x0e, 0x3e8)
		NUL	annuler *	8	0x00
...
		env	Char *	8
8.	0x7FFFFFFFE308.	env	Char *	8	0x7FFFFFFE5E0.
		NUL	annuler *	8	0x00
...
		argv.	Char *	8
9.	0x7FFFFFFFE2F8.	Argv.	Char *	8	0x7FFFFFFFE5BE.
10.	0x7FFFFFFE2F0.	argc.	long int	8"	nombre d'arguments + 1
11.		Variables et arguments locaux, fonctions causées à la principale
12.		Variables locales principales.
13.	0x7FFFFFFFE1FC.	argc.	int.	4	nombre d'arguments + 1
	0x7FFFFFFE1F0.	argv.	char **	8	0x7FFFFFFFE2F8.
	0x7FFFFFFE1E8.	env	char **	8	0x7FFFFFFFE308.
14.		Variables de fonctions locales

«- Je n'ai pas trouvé les descriptions des champs dans les documents, mais le décharge est clairement visible.

Pour 32 bits n'a pas choisi, mais il suffit probablement de diviser les dimensions en deux.

1. Appel aux adresses, au-dessus du point supérieur, causes SEGFAULT.
2. Une chaîne contenant le chemin du fichier exécutable.
3. Tableau de lignes avec variables d'environnement
4. Array de chaînes avec paramètres de ligne de commande
5. Un tableau de longueur aléatoire. Sa sélection peut être désactivée par des commandes.
Systl -w kernel.randomize_va_space \u003d 0
Echo 0\u003e / proc / sys / noyau / randomize_va_space
6. Données pour le vecteur auxiliaire (par exemple, la ligne "x86_64")
7. Vecteur auxiliaire. En savoir plus ci-dessous.
8. Tableau Null-terminal de pointeurs sur des rangées de variables d'environnement
9. Gamme zéro-terminal de pointeurs sur les chaînes de paramètres de ligne de commande
10. Word de la tondeuse contenant le nombre de paramètres de ligne de commande (l'un des arguments des fonctions «senior», voir paragraphe 11)
11. Variables et arguments de la clause, fonctions appelées à Main (_start, __ libc_start_main ..)
12. Invered, déclaré en main
13. Airuments des fonctions principales
14. Mouvement et arguments des fonctions locales.

Vecteur auxiliaire
Pour I386 et X86_64, vous ne pouvez pas obtenir l'adresse du premier élément du vecteur auxiliaire, mais le contenu de ce vecteur peut être obtenu d'une autre manière. L'un d'entre eux est de se référer à la zone de mémoire sous-jacente à la matrice de pointeurs vers les rangées de variables d'environnement.
Cela devrait ressembler à quelque chose comme ça:
#Inclure. #Inclure. Int Main (int Argc, Char ** argv, char ** env) (elf64_auxv_t * Auxv; // x86_64 // elf32_auxv_t * Auxv; // i386 tandis que (* env ++! \u003d Null); // NULL); // Nous recherchons Le début du vecteur auxiliaire pour (AUXV \u003d (elf64_auxv_t *) env; AUXV-\u003e A_TYPE! \u003d AT_NULL; AUXV ++) (PrintF ("Addr:% P Type:% LX est: 0x% LX \\ N", AuxV , Auxv-\u003e a_type, Auxv-\u003e a_un .a_val);) printf ("\\ n (vide *) (* argv) - (vide *) Auxv \u003d% p -% p \u003d% ld \\ n (vide *) ( AUXV) - (vide *) (& Auxv) \u003d% p-% p \u003d% ld \\ n ", (vide *) (* argv), (vide *) Auxv, (vide *) (* ARGV) - (NOID *) AUXV, (NOID *) (ARGV), (NOID *) (& AUXV), (VOID *) (ARGV) - (VOID *) (& AUXV)); Printf ("\\ N Copie Argc:% D \\ n ", * ((int *) (argv - 1))); retour 0;)
Elf (32.64) _AUxv_t Les structures sont décrites dans /usr/include/elf.h. Fonctions de Fulgleenge à Linux-Kernel / FS / BINFMT_FLAC.C

La deuxième façon d'obtenir le contenu du vecteur:
Hexdump / Proc / Self / Auxv

La vue la plus mémorable est obtenue en définissant la variable d'environnement LD_SHOW_AUXV.

Ld_show_auxv \u003d 1 ls
AT_HWCAP: BFEBFBFF // Caractéristiques du processeur
AT_PAGESZZ: 4096 // Taille de la page de la mémoire
AT_CLKTCK: 100 // Mettre à jour les temps de fréquence ()
AT_PHDR: 0x400040 // Informations d'en-tête
AT_PHENT: 56.
AT_PLNUM: 9.
At_base: 0x7fd00b5bc000 // adresse interprète, je veux dire ld.so
AT_FLAGS: 0x0.
AT_Entry: 0x402490 // Pointe d'entrée dans le programme
AT_UID: 1000 // Identificateurs d'utilisateurs et groupes
AT_EUID: 1000 // Nominal et efficace
AT_GID: 1000.
AT_EGID: 1000.
AT_SECURE: 0 // SURIDID SURID
AT_RANDOM: 0x7FFFF30BDC809 // Adresse 16 octets aléatoires,
généré au lancement
At_sysinfo_ehdr: 0x7FFF30BFF000 // Pointeur sur la page utilisée pour
// appels système
At_execfn: / bin / ls
At_platform: x86_64.
À gauche - le nom de la variable, droit à droite. Tous les noms de variables possibles et leur description peuvent être sucré dans le fichier elf.h. (Constantes avec préfixe AT_)

Retour de main ()
Après l'initialisation du contexte du processus, la commande est transmise non dans Main (), mais à la fonction _start ().
Principales () causes de __libc_start_main. Cette dernière fonction a une fonctionnalité intéressante - elle est transmise à une fonction à une fonction qui doit être exécutée après principal (). Et ce pointeur est transmis naturellement à travers la pile.
En général, les arguments __libc_start_main sont visualisés selon le fichier GLIBC-2.11 / SYSDEPS / IA64 / ELF / START.S
/*
* Arguments pour __LIBC_START_MAIN:
* OUT0: MAIN
* OUT1: argc
* OUT2: ARGV
* OUT3: init
* OUT4: FINI // FONCTION appelée après principal
* OUT5: RTLD_FINI
* OUT6: Stack_end
*/
Ceux. Pour obtenir l'adresse Fini Pointer, vous devez passer en deux mots du moteur de la dernière variable locale principale.
C'est ce qui s'est passé (la performance dépend de la version du compilateur):
#Inclure. vide ** ret; vide * leve; Void FOO () (void (* boo) (vide); // pointeur sur la fonction Printf ("Stack réécrit! \\ n"); boo \u003d (vide (*) (vide)); BOO (); // Fini ()) Int Main (int Argc, Char * ARGV, CHAR * ENVP) (non signé Long Int Mark \u003d 0xbfbfbfbfbfbfbfbf; // étiquette à partir de laquelle nous allons travailler RET \u003d (NOID **) (& Mark + 2); // Supprimer les fonctions d'adresse causées après la fin de l'achèvement (Fini) Laissez \u003d * RET; // N'oubliez pas * RET \u003d (VOID *) FOO; // Patch Retour 0; // Appelant la fonction FOO ())

J'espère que c'était intéressant.
Bonne chance

Grâce à l'utilisateur Xeor pour la publication utile.