C usage de l'argument principal. Arguments facultatifs et nommés. Débogage du programme avec arguments de ligne de commande

Mots clés: Paramètres de 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". Cadran de la cmd et vous allez ouvrir 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 se transforme en 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.

Un de plus Équipe importante DIR sous 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 afficher des commandes Windows supplémentaires, tapez la ligne de commande d'aide ou voir le manuel (il est facile à 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.

Il arrive que les données du programme soient transmises de la ligne de commande lorsqu'elle est appelée. Ces données sont appelées arguments de ligne de commande. Cela ressemble à ceci, par exemple:

./a.out test.txt ls -lt / home / peter /

Voici les programmes A.out (dans le répertoire actuel) et LS (d'un répertoire spécifié dans la variable d'environnement de chemin). Le premier programme de la ligne de commande reçoit un mot - test.txt, la seconde est deux: -Lt et / home / peter /.

Si le programme est écrit en C, alors lors de son démarrage, le contrôle est immédiatement transmis à la fonction principale (), c'est donc celui-ci qui obtient les arguments de la ligne de commande qui sont attribués à ses variables.

Avant de cela, nous avons défini la fonction principale () comme s'il n'a pas accepté de paramètres et ne renvoie rien. En fait, dans la langue C, toute fonctionnalité par défaut (si rien d'autre n'est défini) renvoie un entier. Vous pouvez vous assurer que vous pouvez vous assurer. Si vous écrivez le code de cette manière:

principal () (printf ("salut \\ n "); Retour 0; )

Qu'aucun avertissement ni erreur de compilation ne se pose. Il en sera même, si vous enregistrez Int Main (). Cela prouve que la fonction par défaut renvoie un entier et non rien (void). Bien que ce qui renvoie la fonction peut toujours être "remplaçable", par exemple, voidmain () ou float principal ().

Lorsque vous appelez un programme de la ligne de commande, une paire de données est toujours transmise:

entierdésignant le nombre de mots (éléments séparés par des espaces) sur la ligne de commande lorsque vous appelez,
panneau de signalisation sur un tableau de rangéesOù chaque ligne est un mot séparé de la ligne de commande.

Il convient de garder à l'esprit que le nom du programme lui-même est également pris en compte. Par exemple, si l'appel ressemble à ceci:

./a.out 12 Thème 2

Le premier argument du programme est de 4, et le tableau des chaînes est défini comme ("./a.out", "12", "thème", "2").

Faites attention à la terminologie, il n'y a que deux arguments de programme (nombre et tableau), mais tous les arguments de la ligne de commande. Les arguments de ligne de commande sont "convertis" dans les arguments du programme (dans les arguments de la fonction principale).
Ces données (numéro et pointeur) sont transmises au programme même lorsqu'il est simplement appelé par nom sans transférer quelque chose à cela :./.out. Dans ce cas, le premier argument a une valeur de 1, et la seconde indique un tableau constitué d'une seule ligne ("./a.out").

Le fait que le programme soit transmis au programme ne signifie pas que la fonction principale () doit les recevoir. Si la fonction principale () est définie sans paramètres, il est impossible d'accéder aux arguments de la ligne de commande. Bien que rien ne vous dérange de les transférer. Les erreurs ne se poseront pas.

Pour accéder aux données transférées dans le programme, elles doivent être attribuées à des variables. Étant donné que les arguments sont immédiatement transmis à la main (), son titre devrait ressembler à:
Main (INT N, CHAR * ARR)

La première variable (N) contient le nombre de mots et dans le deuxième pointeur de la matrice de ligne. Souvent, le deuxième paramètre est écrit comme ** arr. Cependant, c'est la même chose. Rappelez-vous que la matrice elle-même lignes contient des pointeurs vers des lignes comme ses éléments. Et dans la fonction, nous transmettons un pointeur sur le premier élément de la matrice. Il s'avère que nous transmettons un pointeur au pointeur, c'est-à-dire ** arr.

La tâche
Écrivez un tel programme:

#Inclure. Int Main (int Argc, char * ** argv) (int i; printf ("% d \\ n ", argc); pour (i \u003d 0; i< argc; i++ ) puts (argv[ i] ) ; }

Il affiche le nombre de mots sur la ligne de commande lorsqu'il est appelé et chaque mot avec nouvelle chaîne. Appelez-le sans arguments de ligne de commande et avec des arguments.

Dans le programme, nous avons utilisé les variables ArgC et ARGV. Il est courant d'utiliser de tels noms, mais ils peuvent en fait être de toute façon. Il vaut mieux adhérer à cette norme afin que vos programmes soient plus compréhensibles non seulement pour vous, mais également pour d'autres programmeurs.

La valeur pratique du transfert de données au programme

Si vous avez de l'expérience dans l'invite de commande GNU / Linux, vous savez que la plupart des équipes ont des clés et des arguments. Par exemple, lors de la visualisation du contenu des répertoires, de la copie, de la déplacement d'arguments, des objets sont indiqués système de fichiersSur lequel l'équipe est effectuée. Les caractéristiques de son exécution sont déterminées à l'aide de clés. Par exemple, dans l'équipe

Cp -r ../les_1 ../les_101

cP est le nom de la commande, -r - la clé, et ../ les_1 et ../ les_101 - arguments de commande.

En général, les adresses des fichiers et des "modificateurs" (ce sont les clés) du processus de programme sont transmises dans le programme.

Nous écrirons un programme qui ouvre les fichiers spécifiés par l'utilisateur sur la ligne de commande pour enregistrer ou ajouter et écrit (ajoute) à une seule et même information que l'utilisateur entre dans le clavier pendant le processus d'exécution du programme:

#Inclure. #Inclure. Principal (int argc, char * ** argv) (int i, ch; fichier * f [5]; si (argc< 3 || argc > 7) ( "Nombre non valide de paramètres"); Retour 1; ) Si (STRCMP (ARGV [1], "-W")! \u003d 0 && STRCMP (argv [1], "-a")! \u003d 0) (met ( "Le premier paramètre peut être soit -w, ou -a"); Retour 2; ) pour (i \u003d 0; i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("Le fichier% s ne peut pas être ouvert \\ n", argv [i + 2]); Retour 3; )) Tandis que ((ch \u003d getchar ())! \u003d EOF) pour (i \u003d 0; i; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Explication au code:

Un tableau de cinq points de fichiers est créé. Par conséquent, vous pouvez uniquement ouvrir simultanément plus de cinq fichiers. Le pointeur de fichier du premier fichier sera stocké dans l'élément du F, le second - en F, etc.
Le nombre d'arguments de ligne de commande est vérifié. Ils devraient être au moins trois, car Le premier est le nom du programme, le second - le mode d'ouverture du fichier, le troisième ou le seul fichier dans lequel l'enregistrement sera effectué. Étant donné que le programme vous permet d'ouvrir seulement cinq fichiers, le nombre total d'arguments de ligne de commande ne peut pas être plus sept. Par conséquent, si le nombre d'arguments est inférieur à 3 ou plus de 7, le programme est terminé, car L'opérateur de retour conduit à la sortie de la fonction, même s'il y a toujours du code après cela. La valeur renvoyée de la fonction est inégale 0, peut être interprétée par le processus parent, en tant que message que le programme est terminé avec une erreur.
Vérifié l'exactitude de la deuxième argument de ligne de commande. S'il n'est pas égal à aucun "-w", ni "-a", alors l'expression conditionnelle dans la seconde si le retourne 1 (vrai). La fonction STRCMP () vous permet de comparer des chaînes et de retourner 0 s'ils sont égaux.
La boucle Forcycle ouvre les fichiers aux adresses spécifiées, qui commencent par le troisième élément du tableau ARGV. C'est pourquoi 2 est ajouté à moi, pour recevoir les éléments du tableau Argv, en commençant par la troisième. L'expression argc-2 indique le nombre de noms de fichier passés; Parce que L'ARGC stocke le nombre total d'arguments de ligne de commande, dont les deux premiers ne sont pas des noms de fichiers.
L'expression argv + 1 vous permet de "couper" de la chaîne "-w" (ou "-a") substrant "W" (ou "A"), car ARGV est essentiellement un pointeur sur le premier élément de la chaîne. Ajout à l'unité de pointeur, nous l'évitiions à l'élément suivant de la matrice.
Si le fichier échoue, la fonction fopen () renvoie NULL. Dans ce cas, le programme est terminé.
Chaque caractère entré par l'utilisateur du clavier est écrit à tous les fichiers ouverts.
À la fin, les fichiers sont fermés.

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 sera utilisée par défaut si l'argument correspondant est 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.

En créant application de la console Dans la langue de programmation C ++, la 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 sur la photo, 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.

Dans le programme C, vous pouvez transférer des arguments. Lorsque le calcul au calcul initial est effectué sur la principale (), il est transmis trois paramètres. Les premiers définissent le nombre d'arguments de commande lors de l'accès au programme. La seconde est une gamme de pointeurs à des chaînes symboliques contenant ces arguments (un argument une sur une ligne). La troisième est également une gamme de pointeurs à des chaînes de caractères, il est utilisé pour accéder aux paramètres du système d'exploitation (aux variables d'environnement).

Une telle chaîne semble être:

variable \u003d valeur \\ 0

La dernière chaîne peut être trouvée dans deux zéros finaux.

Nous appelons respectivement les arguments de la fonction principale (): argc, argv et env (tout autre nom sont possibles). Ensuite, les descriptions suivantes sont autorisées:

main (int Argc, char * argv)

main (int Argc, char * argv, char * env)

Supposons que sur le disque A: Il y a un programme PROG.EXE. Se tourner comme suit:

A: \\\u003e PROG.EXE File1 File2 File3

Ensuite, ARGV est un pointeur à une chaîne A: \\ prog.exe, argv - sur la ligne Fichier1, etc. Le premier argument réel indique que l'ARGV et le dernier - argv. Si Argc \u003d 1, puis après le nom du programme, il n'y a pas d'invite de commande de paramètre. Dans notre exemple Argc \u003d 4.

Réursion

Récursion est appelée une telle méthode d'appel dans laquelle la fonction s'adresse elle-même.

L'organisation de la sortie est un point important lors de l'élaboration d'un programme récursif. Il est facile de faire une erreur qui consiste dans le fait que la fonction se causera systématiquement infiniment longtemps. Par conséquent, le processus récursif doit pas passer à pas pour simplifier la tâche de sorte que, à la fin, ce ne soit pas une solution récursive. L'utilisation de la récursivité n'est pas toujours souhaitable, car cela peut entraîner un débordement de pile.

Fonctions de bibliothèque

Dans les systèmes de programmation, le sous-programme à résoudre des tâches courantes est associé à des bibliothèques. Ces tâches incluent: calculer les fonctions mathématiques, les données d'entrée / sortie, le traitement de la ligne, l'interaction avec les outils du système d'exploitation, etc. L'utilisation de sous-routines de bibliothèque élimine l'utilisateur de la nécessité de développer des fonds appropriés et de le fournir un service supplémentaire. Les fonctions incluses dans la bibliothèque sont expédiées avec le système de programmation. Leurs annonces sont données dans * .h des fichiers (ce sont des fichiers dites inclus ou d'en-tête). Par conséquent, comme déjà mentionné ci-dessus, au début du programme avec des fonctions de bibliothèque devrait être des chaînes de la forme:

#Inclure.<включаемый_файл_типа_h>

Par example:

#Inclure.

Il existe également des moyens pour développer et créer de nouvelles bibliothèques avec des programmes utilisateur.

Pour les variables globales, une place fixe est attribuée en mémoire à tout moment du programme. Les variables locales sont stockées dans la pile. Entre eux est une zone de mémoire pour la distribution dynamique.

Les fonctions MALLOC () et GRATUITES () sont utilisées pour distribuer de manière dynamique la mémoire libre. La fonctionnalité MALLOC () met en évidence la mémoire, la fonction libre () libère-la. Les prototypes de ces fonctions sont stockés dans le fichier d'en-tête STDLIB.H et ont la forme:

vide * malloc (taille_t);

vide * libre (vide * p);

La fonction MALLOC () renvoie un indicateur de vide; Pour une utilisation correcte, la valeur de fonction doit être convertie au pointeur sur le type approprié. Lors de l'exécution réussie, la fonction renvoie un pointeur sur le premier octet de la taille de taille de taille libre. S'il n'y a pas de quantité suffisante de mémoire, la valeur est 0. Pour déterminer le nombre d'octets requis pour la variable, utilisez la taille de fonctionnement ().

Un exemple d'utilisation de ces fonctions:

#Inclure.

p \u003d (int *) malloc (100 * taille de (int)); / * Allocation de mémoire pour 100

nombres entiers * /

printf ("pas assez de mémoire \\ n");

pour (i \u003d 0; i< 100; ++i) *(p+i) = i; /* Использование памяти */

pour (i \u003d 0; i< 100; ++i) printf("%d", *(p++));

libre (p); / * Libération de la mémoire * /

Avant d'utiliser le pointeur renvoyé par MALLOC (), vous devez vous assurer que la mémoire est suffisante (le pointeur n'est pas zéro).

Préprocesseur

Le préprocesseur Si est un programme qui traite l'entrée du compilateur. Le préprocesseur parcourant le programme source et effectue les actions suivantes: connecte les fichiers spécifiés à celui-ci, fait des substitutions et contrôle également les conditions de compilation. Pour le préprocesseur, les rangées du programme commençant par le symbole # sont conçues. Une ligne est autorisée à enregistrer une seule commande (directive de préprocesseur).

Directif

Identifiant de substitution #define

cause un remplacement dans le texte suivant du programme de l'identifiant nommé sur le texte de la substitution (faites attention à l'absence d'un point avec une virgule à la fin de cette commande). Essentiellement, cette directive entre dans la définition de la macro (macro), dans laquelle l'identifiant "est le nom de la définition macro et la" substitution "est une séquence de caractères auxquels le prétraiteur remplace le nom spécifié lorsqu'il le trouve dans le texte du programme. . Le nom de la définition macro est prise par des lettres majuscules.

Considérons des exemples:

La première ligne appelle le remplacement du programme Max Identificateur à la constante 25. La seconde vous permet d'utiliser dans le texte au lieu de l'attelle d'ouverture (() le mot commence.

Nous notons que, étant donné que le préprocesseur ne vérifie pas la compatibilité entre les noms symboliques des définitions de macro et le contexte dans lequel ils sont utilisés, il est recommandé de déterminer que de tels identifiants sont recommandés pour déterminer la directive #define, mais en utilisant le mot-clé Const avec un Type de type explicite (ceci est plus lié à C + +):

const int max \u003d 25;

(Le type INT ne peut pas spécifier, car il est installé par défaut).

Si la directive #define est:

#Define identifiant (identifiant, ..., identifiant) Substitution

de plus, il n'y a pas d'espace entre le premier identifiant et le support d'ouverture, il s'agit de la définition des macro-arguments avec des arguments. Par exemple, après l'apparition d'une chaîne de formulaire:

#Define Lire (VAL) Scanf ("% D", & val)

lire (y) opérateur; perçu comme Scanf ("% D", & Y) ;. Ici, Val est un argument et une macro-argument avec l'argument.

S'il existe de longues définitions dans la substitution de la ligne suivante, à la fin de la ligne suivante, le symbole \\ est défini.

Dans la définition de la macro, vous pouvez mettre des objets séparés par ## caractères, par exemple:

#Define pr (x, y) x# y

Après cela, PR (A, 3) provoquera la substitution A3. Ou, par exemple, définition macro

#Define z (A, B, C, D) A (B ## C ## D)

sera remplacé par z (péché, x, +, y) sur le péché (x + y).

Le symbole # placé devant le macroartum indique la conversion dans la chaîne. Par exemple, après la directive

#Define prim (var) printf (#var "\u003d% d", var)

prochain fragment du texte du programme

converti donc:

printf ("année" "\u003d% d", année);

Nous décrivons d'autres directives de préprocesseur. La directive #include s'est déjà remplie plus tôt. Il peut être utilisé sous deux formes:

#Include "Nom du fichier"

#Inclure.<имя файла>

L'action des deux commandes est réduite pour activer les fichiers avec le nom spécifié. Les premiers téléchargent un fichier à partir du préfixe actuel ou spécifié en tant que préfixe de catalogue. La deuxième commande recherche un fichier dans des emplacements standard définis dans le système de programmation. Si le fichier dont le nom est enregistré dans des guillemets doubles, non trouvé dans le répertoire spécifié, la recherche sera poursuivie dans les sous-répertoires spécifiés pour la commande #include.<...>. #Include les directives peuvent être investies les unes dans les autres.

Le groupe de directives suivant vous permet de compiler sélectivement des parties du programme. Ce processus s'appelle une compilation conditionnelle. Ce groupe comprend #iS, #else, #elif, #endif, #Ifdef, #Ifndef directives. La forme principale de l'enregistrement de la directive #IF est:

#if constante_construction Séquence_perators

Ici la valeur de l'expression constante est vérifiée. S'il est vrai, la séquence spécifiée des opérateurs est effectuée et si elle est fausse, cette séquence d'opérateurs est ignorée.

L'action de la directive #else est similaire à l'action de la commande d'enseigne à S S, par exemple:

# à l'emploi constant)

séquence_ Operators_2.

Ici, si l'expression constante est vraie, les séquenceurs de séquenceurs_1 sont effectués et si faussement - Séquence_2.

#LIFI Directive signifie type "sinon si". La forme principale de son utilisation a la forme:

# à l'emploi constant)

séquence_ Opérateurs

#elif constante_mapsion_1

séquence_Perrator_1.

#elif constante_néne_n.

séquence_Perrator_n.

Ce formulaire est similaire à la conception du type Si: si ... autre si ... sinon si ...

Directif

# Identifiant #Ifdef

définit l'identifiant spécifié pour le moment, c'est-à-dire S'il est entré dans la directive sur les espèces #define. Rangée de type

Identifiant #IFNDEF

vérifie si l'identifiant spécifié est actuellement en ce moment. Pour l'une de ces directives, un nombre arbitraire de chaînes de texte peut être suivi par le #else (#elif ne peut pas être utilisé) et se terminant par la chaîne #undIF. Si la condition de test est vraie, toutes les lignes entre #elSe et #endif sont ignorées, et si elles sont faussement, les lignes entre la vérification et le #else (si #else mots ne sont pas, alors #endif). #If et #Ifndef directives peuvent "activer" un à l'autre.

Vue directive

#DIDEF identifiant

conduit au fait que l'identifiant spécifié commence à être considéré comme incertain, c'est-à-dire pas sujet à remplacer.

Considérer des exemples. Trois directives suivantes:

vérifiez si l'identifiant d'écriture est défini (c'est-à-dire une équipe de l'espèce #define écrit ...), et si oui, le nom de l'écriture commence à être considéré comme incertain, c'est-à-dire pas sujet à remplacer.

Directif

#Define écrit fprintf.

vérifiez si l'identifiant d'écriture est incertain et si tel est le cas, l'identifiant d'écriture sera déterminé à la place du nom FPRINTF.

La directive #Error est écrite sous la forme suivante:

#Error Message_ab_obkka

S'il est trouvé dans le texte du programme, la compilation s'arrête et un message d'erreur s'affiche sur l'écran d'affichage. Cette commande est principalement appliquée à la phase de débogage. Notez que le message d'erreur n'a pas besoin d'entrer dans des guillemets doubles.

La directive #Line est conçue pour modifier les valeurs des variables _line_ et _file_ définies dans le système de programmation SI. La variable _line_ contient le numéro de la chaîne de programme effectuée à l'heure actuelle. L'identifiant _file_ est un pointeur à une chaîne avec le nom du programme compilé. La directive #Line est écrite comme suit:

#Line numéro "Nom du fichier"

Ici, le nombre est un entier positif qui sera attribué à la variable _line_, le nom_name est un paramètre facultatif qui remplace la valeur _file_.

La directive #pragma vous permet de transférer des instructions au compilateur. Par exemple, string

il suggère que le programme dans la langue SI a des lignes dans la langue des assembleurs. Par example:

Considérez des identifiants ou des macroenases globaux (noms de définition de macro). Cinq de ces noms sont définis: _line_, _file_, _date_, _time_, _stdc_. Deux d'entre eux (_line_ et _file_) ont déjà été décrits ci-dessus. L'identifiant _Date_ définit une chaîne dans laquelle les données de la transmission du fichier source sont enregistrées sur le code d'objet. L'identifiant _Time_ définit la chaîne qui enregistre l'heure de transmission du fichier source sur le code d'objet. Macro _stdc_ est 1, s'il est utilisé une macrosquace standard spécifique à la norme. Sinon, cette variable ne sera pas déterminée.