C folosind argumentul principal. Argumente opționale și denumite. Depanarea unui program cu argumente din linia de comandă

Etichete: Parametrii liniei de comandă

Parametrii liniei de comandă

C și - un limbaj compilat. Odată asamblat, programul este un fișier executabil (nu luăm în considerare crearea de biblioteci dinamice, drivere etc.). Programele noastre sunt foarte simple și nu conțin biblioteci Runtime, deci pot fi transferate pe un computer cu același sistem de operare (și arhitectură similară) și rulate acolo.

Programul poate accepta parametrii în timpul pornirii. Acestea sunt argumentele funcției principale. Vederea generală a funcției principale este următoarea

Void main (int argc, char ** argv) (...)

Primul argument argc este numărul de parametri trecuți funcției. Al doilea argument este o serie de șiruri - parametrii înșiși. Deoarece parametrii funcției pot fi oricare, aceștia sunt trecuți ca șiruri, iar programul în sine trebuie să-i analizeze și să-i convertească la tipul dorit.

Primul argument (argv) este întotdeauna numele programului. În acest caz, numele este afișat în funcție de unde a fost lansat programul.

#include #include void main (int argc, char ** argv) (printf ("% s", argv);)

Acum, să învățăm cum să lucram puțin cu linia de comandă. Avem nevoie de acest lucru pentru a transmite argumente programului nostru. Comanda rapidă de la tastatură Win + R afișează fereastra Run. Tastați cmd în ea și veți deschide Linie de comanda... De asemenea, puteți găsi cmd.exe căutând în meniul Start. În unix-like sisteme de operare ah poți apela programul „terminal”.

Nu vom studia multe comenzi. Doar cele necesare în muncă.

Comanda CD, standard pentru toate sistemele de operare, trece la dosarul dorit... Există două nume rezervate -. (punct) și .. (două puncte). Perioada este numele folderului curent.

Nu merge nicăieri

Referindu-ne la folderul părinte

Mutați în dosarul părinte

Pentru a merge la cea dorită, scrieți adresa cd. De exemplu, trebuie să accesați Windows în folderul C: \ Windows \ System32

Cd C: \ Windows \ System32

În Linux, dacă trebuie să accesați folderul / var / mysql

Cd / var / mysql

Dacă calea conține spații, atunci este scrisă între ghilimele duble

Cd "D: \ Documente și setări \ Prolog"

Terminalul are următoarele caracteristici utile: dacă apăsați săgeata sus, va apărea comanda executată anterior. Dacă apăsați tasta, terminalul va încerca să completeze linia către comanda pe care o cunoaște sau să completeze calea, parcurgând toate folderele și fișierele din folderul curent.
Tastați cd C: \
apăsați fila și urmăriți ce se întâmplă.

Încă unul echipă importantă dir pe windows și ls pe linux, imprimă pe consolă conținutul folderului curent (folderul în care vă aflați în prezent)

Programul dvs. a returnat numele complet. Accesați folderul în care se află programul dvs. și vizualizați conținutul acestuia

Acum, după ce am navigat în dosarul nostru, putem executa programul nostru. Pentru a face acest lucru, introduceți numele ei.

Notă - numele s-a schimbat. Deoarece programul este apelat din propriul folder, se afișează numele relativ. Acum să schimbăm programul pentru a imprima toate argumentele. care i-au fost transferate.

#include #include void main (int argc, char ** argv) (int i; for (i = 0; i< argc; i++) { printf("%s\n", argv[i]); } }

Construiește proiectul. Asigurați-vă că programul este închis înainte de a construi. Acum apelați programul transmițându-i diferite argumente. Pentru a face acest lucru, scrieți numele programului și argumentele separate printr-un spațiu

Să scriem acum un program care să ia două argumente numerice și să le scoată suma

#include #include #include void main (int argc, char ** argv) (int a, b; if (argc! = 3) (printf ("Eroare: s-au găsit% d argumente. Necesită exact 2", argc-1); exit (1); ) a = atoi (argv); b = atoi (argv); printf ("% d", a + b);)

Vom colecta și vom suna

Așa funcționează majoritatea programelor. Făcând clic pe o comandă rapidă, apelați programul la care se referă. Majoritatea programelor acceptă, de asemenea diverse argumente... De exemplu, puteți apela browser Firefox din linia de comandă și treceți argumentele
firefox.exe "www.mozilla.org" "site" și se va deschide imediat în două file site-uri de pe adrese specificate.

Multe comenzi standard au și parametri. În Windows, se acceptă faptul că acestea încep cu o bară înainte, în Unix cu un minus sau două minus. De exemplu

Afișează numai foldere și în terminalul Linux

Ls -l listează toate fișierele și folderele cu atribute

Pentru a vizualiza suplimentar comenzi Windows tastați help pe linia de comandă sau consultați manualul (este ușor de găsit pe internet). Există mai multe comenzi și opțiunile lor pentru Linux, iar unele dintre ele sunt limbaje de programare independente, deci merită să învățați cel puțin un set minim și opțiunile lor.

Se întâmplă ca datele să fie transmise programului din linia de comandă atunci când sunt apelate. Aceste date se numesc argumente de linie de comandă. Arată așa, de exemplu:

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

Aceasta apelează programele a.out (din directorul curent) și ls (din același director specificat în variabila de mediu PATH). Primul program din linia de comandă primește un cuvânt - test.txt, al doilea - două: -lt și / home / peter /.

Dacă programul este scris în C, atunci când pornește, controlul este trecut imediat funcției main (), prin urmare, acesta primește argumentele din linia de comandă care sunt atribuite variabilelor parametrului său.

Înainte de aceasta, am definit funcția main () ca și cum nu ar lua parametri și nu a returnat nimic. De fapt, în C, orice funcție implicită (dacă nu se specifică altfel) returnează un număr întreg. Acest lucru poate fi verificat. Dacă scrieți codul astfel:

main () (printf ("Bună \ n "); retur 0; )

Atunci nu va apărea nicio eroare de avertizare sau compilare. La fel se va întâmpla dacă scrieți int main (). Aceasta dovedește că funcția implicită returnează un număr întreg, nu nimic (nul). Deși, ceea ce returnează funcția poate fi întotdeauna „suprascris”, de exemplu, voidmain () sau float main ().

Când apelați un program din linia de comandă, o pereche de date îi este transmisă întotdeauna:

întreg, indicând numărul de cuvinte (elemente separate prin spații) pe linia de comandă atunci când este invocat,
pointer la matrice de șiruri unde fiecare linie este un cuvânt separat de linia de comandă.

Rețineți că și numele programului în sine contează. De exemplu, dacă apelul arată astfel:

./a.out 12 tema 2

Apoi primul argument al programului are valoarea 4, iar matricea de șiruri este definită ca ("./a.out", "12", "tema", "2").

Acordați atenție terminologiei, există doar două argumente ale programului (număr și matrice), dar cât de multe argumente din linia de comandă doriți. Argumentele din linia de comandă sunt „convertite” în argumente ale programului (în argumente în funcția main ()).
Aceste date (număr și pointer) sunt transmise programului chiar și atunci când sunt pur și simplu apelate pe nume fără a-i transmite nimic: ./a.out. În acest caz, primul argument este 1, iar al doilea indică o matrice de o singură linie („./a.out”).

Faptul că datele sunt transmise către program nu înseamnă că funcția main () ar trebui să le primească. Dacă funcția main () este definită fără parametri, atunci argumentele din linia de comandă nu pot fi accesate. Deși nimic nu vă împiedică să le transferați. Nu va apărea nicio eroare.

Pentru a accesa datele transferate programului, acestea trebuie alocate variabilelor. Deoarece argumentele sunt transmise imediat către main (), antetul său ar trebui să arate astfel:
main (int n, char * arr)

Prima variabilă (n) conține numărul de cuvinte, iar a doua conține un pointer către o matrice de șiruri. Al doilea parametru este adesea scris ca ** arr. Cu toate acestea, este la fel. Amintiți-vă că matricea de șiruri în sine conține indicii către șiruri ca elemente. Și în funcție trecem un pointer către primul element al matricei. Se pare că trecem un pointer către un pointer, adică ** ar.

Sarcina
Scrie un program ca acesta:

#include int main (int argc, char ** argv) (int i; printf ("% d \ n ", argc); pentru (i = 0; i< argc; i++ ) puts (argv[ i] ) ; }

Tipărește numărul de cuvinte pe linia de comandă atunci când este invocat și fiecare cuvânt cu linie nouă... Apelați-l fără argumente de linie de comandă și cu argumente.

În program, am folosit variabilele parametrilor argc și argv. Este obișnuit să folosiți doar astfel de nume, dar de fapt ele pot fi orice. Este mai bine să respectați acest standard, astfel încât programele dvs. să fie mai ușor de înțeles nu numai pentru dvs., ci și pentru alți programatori.

Importanța practică a transferului de date către program

Dacă aveți experiență cu linia de comandă GNU / Linux, știți că majoritatea comenzilor au comutatoare și argumente. De exemplu, atunci când răsfoiți conținutul directoarelor, copierea, mutarea, obiectele sunt specificate ca argumente Sistemul de fișiere pe care se execută comanda. Particularitățile implementării sale sunt determinate cu ajutorul tastelor. De exemplu, în comandă

Cp -r ../les_1 ../les_101

cp este numele comenzii, -r este comutatorul și ../ les_1 și ../ les_101 sunt argumentele comenzii.

În general, cel mai adesea la lansarea programelor, adresele de fișiere și „modificatorii” (acestea sunt cheile) procesului de execuție a programului sunt transmise programelor.

Să scriem un program care deschide fișierele specificate de utilizator pe linia de comandă pentru a scrie sau adăuga și scrie (adaugă) acolo aceleași informații pe care utilizatorul le introduce de la tastatură în timpul executării programului:

#include #include main (int argc, char ** argv) (int i, ch; FILE * f [5]; if (argc< 3 || argc >7) (pune ( „Număr nevalid de parametri”); retur 1; ) if (strcmp (argv [1], "-w")! = 0 && strcmp (argv [1], "-a")! = 0) (pune ( „Primul parametru poate fi -w sau -a”); retur 2; ) pentru (i = 0; i< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("Fișierul% s nu poate fi deschis \ n", argv [i + 2]); retur 3; )) while ((ch = getchar ())! = EOF) pentru (i = 0; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Explicații pentru cod:

Se creează o matrice de cinci indicatoare de fișiere. Prin urmare, nu puteți deschide mai mult de cinci fișiere odată. Indicatorul de fișier al primului fișier va fi stocat în elementul matricei f, al doilea în f și așa mai departe.
Se verifică numărul argumentelor din linia de comandă. Ar trebui să fie cel puțin trei, pentru că primul este numele programului, al doilea este modul de deschidere a fișierului, al treilea este primul sau singurul fișier în care trebuie scris. Deoarece programul poate deschide doar cinci fișiere, numărul total de argumente din linia de comandă nu poate depăși șapte. Prin urmare, dacă numărul argumentelor este mai mic de 3 sau mai mare de 7, atunci programul se încheie, deoarece declarația return face ca funcția să iasă, chiar dacă există mai mult cod după aceasta. Valoarea returnată din funcție, care nu este egală cu 0, poate fi interpretată de procesul părinte ca un mesaj că programul a încheiat cu o eroare.
Se verifică validitatea celui de-al doilea argument din linia de comandă. Dacă nu este nici „-w” și nici „-a”, atunci expresia condițională din a doua dacă returnează 1 (adevărat). Funcția strcmp () vă permite să comparați șirurile și returnează 0 dacă sunt egale.
Bucla for deschide fișiere la adresele specificate care încep de la al treilea element al matricei argv. De aceea 2 este adăugat la i pentru a obține elementele matricei argv începând cu a treia. Argc-2 indică numărul de nume de fișiere trecute; de cand argc stochează numărul total de argumente din linia de comandă, dintre care primele două nu sunt nume de fișiere.
Expresia argv + 1 vă permite să „tăiați” șirul „w” (sau „a”) din șirul „-w” (sau „-a”), deoarece argv este în esență un indicator către primul element al șirului. Adăugând unul la pointer, îl mutăm la următorul element din matrice.
Dacă fișierul nu poate fi deschis, funcția fopen () returnează NULL. În acest caz, programul se încheie.
Fiecare caracter introdus de utilizator de la tastatură este scris în toate fișierele deschise.
La final, fișierele sunt închise.

Argumente opționale și denumite

Argumente opționale

C # 4.0 introduce o nouă caracteristică care îmbunătățește confortul specificării argumentelor atunci când se apelează o metodă. Acest remediu se numește argumente opționaleși vă permite să definiți o valoare implicită pentru un parametru de metodă. Această valoare va fi utilizată implicit dacă nu este specificat niciun argument corespunzător pentru parametru atunci când se apelează metoda. Prin urmare, nu este necesar să se furnizeze un argument pentru un astfel de parametru. Argumentele opționale vă permit să simplificați apelurile de metodă prin aplicarea unor argumente implicite unor parametri. Ele pot fi, de asemenea, folosite ca o formă de "stenogramă" de supraîncărcare a metodei.

Principalul stimulent pentru adăugarea de argumente opționale a fost necesitatea de a simplifica interacțiunea cu obiectele COM. Mai multe modele de obiecte Microsoft (de exemplu, Microsoft Office) funcționalitatea este furnizată prin obiecte COM, dintre care multe au fost scrise cu mult timp în urmă și au fost proiectate pentru a utiliza parametri opționali.

Un exemplu de utilizare a argumentelor opționale este prezentat mai jos:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 (clasa Program (// Argumentele b și c sunt opționale pentru a specifica când se apelează static int mySum (int a, int b = 5, int c = 10) (returnează a + b + c;) static void Main () ( int sum1 = mySum (3); int sum2 = mySum (3,12); Console.WriteLine ("Sum1 =" + sum1); Console.WriteLine ("Sum2 =" + sum2); Console.ReadLine ();)) )

Trebuie avut în vedere faptul că toate argumentele opționale trebuie specificate în dreapta celor solicitate. În plus față de metode, argumentele opționale pot fi utilizate în constructori, indexatori și delegați.

Avantajul argumentelor opționale este, în special, că le facilitează programatorilor să facă față apelurilor complexe de metode și constructori. La urma urmei, este adesea necesar să specificați mai mulți parametri într-o metodă decât este de obicei necesar. Și în astfel de cazuri, unii dintre acești parametri pot fi opționali prin utilizarea atentă a argumentelor opționale. Aceasta înseamnă că trebuie să transmiteți numai acele argumente care sunt importante în acest caz particular și nu toate argumentele care ar trebui altfel solicitate. Această abordare vă permite să raționalizați metoda și să simplificați gestionarea de către programator a acesteia.

Argumente numite

Încă una funcționalitate, care a fost adăugat la C # odată cu lansarea .NET 4.0, este suport pentru așa-numitul argumente numite... După cum știți, atunci când transmiteți argumente unei metode, ordinea în care apar, de regulă, ar trebui să coincidă cu ordinea în care parametrii sunt definiți în metoda însăși. Cu alte cuvinte, o valoare a argumentului este atribuită unui parametru prin poziția sa în lista de argumente.

Argumentele numite sunt menite să depășească această limitare. Un argument numit vă permite să specificați numele parametrului căruia i se atribuie valoarea. Și în acest caz, ordinea argumentelor nu mai contează. Astfel, argumentele numite sunt oarecum similare cu inițializatoarele de obiecte menționate anterior, deși diferă de ele prin sintaxă. Sintaxa pentru specificarea unui argument pe nume este:

nume_parametru: valoare

Aici nume_parametru denotă numele parametrului la care este trecută valoarea. Desigur, parametru_nume trebuie să denumească numele unui parametru valid pentru metoda apelată.

În timp ce creați aplicație de consolăîn limbajul de programare C ++, se generează automat o linie foarte asemănătoare cu aceasta:

Int main (int argc, char * argv) // parametrii funcției main ()

Această linie este titlul functie principala main (), parametrii argс și argv sunt declarați între paranteze. Deci, dacă programul este rulat prin linia de comandă, atunci este posibil să transferați orice informație către acest program, pentru aceasta există parametrii argc și argv. Parametrul argc este de tipul de date int și conține numărul de parametri trecuți funcției principale. Mai mult, argc este întotdeauna cel puțin 1, chiar și atunci când nu transferăm nicio informație, deoarece primul parametru este numele funcției. Parametrul argv este o matrice de indicatori către șiruri. Numai datele șirului pot fi transmise prin linia de comandă. Indicatoarele și șirurile sunt două subiecte mari pentru care secțiuni separate... Deci, prin intermediul parametrului argv este transmisă orice informație. Vom dezvolta un program pe care îl vom executa prin comandă Șir Windows, și transferați-i câteva informații.

// argc_argv.cpp: definește punctul de intrare pentru aplicația consolă. #include "stdafx.h" #include folosind spațiul de nume std; int main (int argc, char * argv) (if (argc><< argv<

// cod Cod :: Blocuri

// Cod Dev-C ++

// argc_argv.cpp: definește punctul de intrare pentru aplicația consolă. #include folosind spațiul de nume std; int main (int argc, char * argv) (dacă (argc> 1) // dacă trecem argumente, atunci argc va fi mai mare de 1 (în funcție de numărul de argumente) (cout<< argv<

După depanarea programului, deschideți linia de comandă Windows și trageți executabilul programului nostru în fereastra liniei de comandă, calea completă către program va fi afișată pe linia de comandă (dar puteți introduce calea către program manual), după pe care puteți face clic INTRODUCE iar programul va începe (vezi Figura 1).

Figura 1 - Parametrii funcției principale

Deoarece tocmai am rulat programul și nu i-am transmis niciun argument, a apărut mesajul Nu argumente. Figura 2 arată lansarea aceluiași program prin linia de comandă, dar cu argumentul Deschis transmis.

Figura 2 - Parametrii funcției principale

Argumentul este cuvântul Deschis, după cum puteți vedea din imagine, acest cuvânt a apărut pe ecran. Puteți transfera mai mulți parametri simultan, separându-i cu o virgulă. Dacă este necesar să treceți un parametru format din mai multe cuvinte, atunci acestea trebuie să fie încadrate între ghilimele duble, iar aceste cuvinte vor fi numărate ca un singur parametru. De exemplu, figura arată lansarea unui program, trecându-i un argument format din două cuvinte - Funcționează.

Figura 3 - Parametrii funcției principale

Și dacă eliminați ghilimelele. Atunci vom vedea doar cuvântul It. Dacă nu intenționați să transferați nicio informație la pornirea programului, atunci puteți elimina argumentele din funcția main (), puteți schimba și numele acestor argumente. Uneori există modificări ale parametrilor argc și argv, dar totul depinde de tipul de aplicație creată sau de mediul de dezvoltare.

Anumite argumente pot fi transmise programelor C. Când main () este apelat la începutul unui calcul, îi sunt trecuți trei parametri. Primul determină numărul de argumente de comandă la apelarea programului. Al doilea este un set de indicatori către șiruri de caractere care conțin aceste argumente (un argument pe linie). Al treilea este, de asemenea, o serie de indicatori către șiruri de caractere; este utilizat pentru a accesa parametrii sistemului de operare (variabile de mediu).

Orice astfel de linie este reprezentată ca:

variabilă = valoare \ 0

Ultima linie poate fi găsită de cele două zerouri finale.

Să numim argumentele funcției main (), respectiv: argc, argv și env (orice alte nume sunt posibile). Apoi, următoarele descrieri sunt valabile:

principal (int argc, char * argv)

principal (int argc, char * argv, char * env)

Să presupunem că aveți un program prog.exe pe unitatea A :. Să ne referim la aceasta după cum urmează:

A: \> prog.exe fișier1 fișier2 fișier3

Apoi, argv este un pointer către șirul A: \ prog.exe, argv este către fișierul șir 1, etc. Primul argument actual este indicat de argv, iar ultimul este indicat de argv. Dacă argc = 1, atunci nu există parametri după numele programului pe linia de comandă. În exemplul nostru, argc = 4.

Recursivitate

Recursivitatea este o metodă de apel în care o funcție se numește singură.

Un punct important atunci când scrieți un program recursiv este organizarea ieșirii. Este ușor să faceți greșeala de a face o funcție să se numească secvențial la infinit. Prin urmare, un proces recursiv trebuie să simplifice pas cu pas problema, astfel încât în final să apară o soluție non-recursivă pentru aceasta. Utilizarea recursivității nu este întotdeauna de dorit, deoarece poate duce la depășiri de stive.

Funcțiile bibliotecii

În sistemele de programare, subrutinele pentru rezolvarea problemelor comune sunt combinate în biblioteci. Aceste sarcini includ: calcularea funcțiilor matematice, intrarea / ieșirea datelor, procesarea șirurilor, interacțiunea cu instrumentele sistemului de operare etc. Utilizarea rutinelor de bibliotecă eliberează utilizatorul de necesitatea dezvoltării instrumentelor adecvate și îi oferă servicii suplimentare. Funcțiile incluse în biblioteci sunt furnizate împreună cu sistemul de programare. Declarațiile lor sunt date în fișiere * .h (acestea sunt așa-numitele fișiere include sau antet). Prin urmare, așa cum s-a menționat mai sus, la începutul programului cu funcții de bibliotecă ar trebui să existe linii de formular:

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

De exemplu:

#include

Există, de asemenea, facilități pentru extinderea și crearea de biblioteci noi cu programe de utilizator.

Pentru variabilele globale, un spațiu de memorie fix este alocat pentru întreaga durată a programului. Variabilele locale sunt stocate în stivă. În mijloc este o zonă de memorie pentru alocare dinamică.

Funcțiile malloc () și free () sunt utilizate pentru a aloca dinamic memoria liberă. Funcția malloc () alocă memorie, funcția free () o eliberează. Prototipurile acestor funcții sunt stocate în fișierul antet stdlib.h și arată astfel:

void * malloc (size_t size);

void * gratuit (void * p);

Funcția malloc () returnează un pointer gol; pentru o utilizare corectă, valoarea funcției trebuie convertită într-un pointer la tipul corespunzător. La succes, funcția returnează un indicator la primul octet de memorie liberă de dimensiune. Dacă nu există suficientă memorie, se returnează valoarea 0. Pentru a determina numărul de octeți necesari pentru o variabilă, utilizați operația sizeof ().

Un exemplu de utilizare a acestor funcții:

#include

p = (int *) malloc (100 * sizeof (int)); / * Alocați memorie pentru 100

numere întregi * /

printf ("Memorie insuficientă \ n");

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

pentru (i = 0; i< 100; ++i) printf("%d", *(p++));

gratuit (p); / * Memorie libera * /

Înainte de a utiliza indicatorul returnat de malloc (), trebuie să vă asigurați că există suficientă memorie (indicatorul nu este nul).

Preprocesator

Un preprocesor C este un program care procesează intrarea în compilator. Preprocesatorul se uită la programul sursă și efectuează următoarele acțiuni: conectează fișierele specificate la acesta, efectuează înlocuiri și, de asemenea, controlează condițiile de compilare. Pentru preprocesor, există linii de program care încep cu caracterul #. O singură comandă (directivă preprocesor) este permisă pe linie.

Directivă

#define substituirea id

determină înlocuirea identificatorului numit în textul programului ulterior cu textul de substituție (rețineți absența unui punct și virgulă la sfârșitul acestei comenzi). În esență, această directivă introduce o definiție macro (macro), unde „identificator” este numele definiției macro, iar „substituire” este o secvență de caractere cu care preprocesorul înlocuiește numele specificat atunci când îl găsește în textul programului. Se obișnuiește să tastați numele unei macro cu litere mari.

Să vedem câteva exemple:

Prima linie face ca programul să înlocuiască identificatorul MAX cu constanta 25. A doua vă permite să utilizați cuvântul BEGIN în loc de deschiderea acoladei (() din text.

Rețineți că, din moment ce preprocesorul nu verifică compatibilitatea între numele simbolice ale definițiilor macro și contextul în care acestea sunt utilizate, se recomandă definirea unor astfel de identificatori nu cu directiva #define, ci folosind cuvântul cheie const cu o indicație de tip explicit (acest este mai mult legat de C + +):

const int MAX = 25;

(tipul int poate fi omis, deoarece este setat implicit).

Dacă directiva #define arată astfel:

#define substituție id (id, ..., id)

și nu există spațiu între primul identificator și paranteză de deschidere, atunci aceasta este o definiție de substituție macro cu argumente. De exemplu, după apariția unei linii de genul:

#define READ (val) scanf ("% d", & val)

CITIȚI declarația (y); este interpretat în același mod ca scanf ("% d", & y); Aici val este un argument și s-a efectuat substituirea macro cu un argument.

Dacă există definiții lungi de substituție care continuă pe următoarea linie, caracterul \ este plasat la sfârșitul următoarei linii de continuare.

Obiectele separate prin simboluri ## pot fi plasate într-o definiție macro, de exemplu:

#define PR (x, y) x ## y

După aceea, PR (a, 3) va provoca substituirea a3. Sau, de exemplu, definiția macro

#define z (a, b, c, d) a (b ## c ## d)

va avea ca rezultat înlocuirea lui z (sin, x, +, y) cu sin (x + y).

Caracterul #, plasat înaintea argumentului macro, indică conversia acestuia într-un șir. De exemplu, după directivă

#define PRIM (var) printf (#var "=% d", var)

următoarea piesă de text al programului

este convertit astfel:

printf ("an" "=% d", an);

Să descriem alte directive preprocesor. Directiva #include a fost deja întâlnită. Poate fi folosit sub două forme:

#include "nume de fișier"

#include<имя файла>

Acțiunea ambelor comenzi este redusă la includerea fișierelor cu numele specificat în program. Primul încarcă un fișier din directorul curent sau prefixat. A doua comandă caută fișierul în locații standard definite în sistemul de programare. Dacă fișierul al cărui nume este scris între ghilimele duble nu se găsește în directorul specificat, atunci căutarea va continua în subdirectoarele specificate pentru comanda #include<...>... Directivele #Include pot fi imbricate una în alta.

Următorul grup de directive vă permite să compilați selectiv părți ale unui program. Acest proces se numește compilare condițională. Acest grup include directivele #if, #else, #elif, #endif, #ifdef, #ifndef. Principala formă a directivei #if este:

#ifestare_expresie constantă_existență_declarație

Valoarea expresiei constante este verificată aici. Dacă este adevărat, atunci se execută secvența de instrucțiuni specificată, iar dacă este falsă, atunci această secvență de instrucțiuni este omisă.

Acțiunea directivei #else este similară acțiunii comenzii else din C, de exemplu:

#dacă exprimarea_constantă

statement_sequence_2

Aici, dacă expresia constantă este adevărată, atunci se execută statement_sequence_1, iar dacă este falsă, atunci statement_sequence_2 se execută.

Directiva #elif înseamnă o acțiune „altfel dacă”. Principala formă de utilizare a acestuia este următoarea:

#dacă exprimarea_constantă

statement_sequence

#elif constant_expression_1

statement_sequence_1

#elif constant_expression_n

statement_sequence_n

Această formă este similară cu construcția limbajului C al formei: if ... else if ... else if ...

Directivă

#ifdef identificator

stabilește dacă identificatorul specificat este definit în prezent, adică dacă a fost inclus în directive precum #define. Vizualizați linia

#ifndef identificator

verifică dacă identificatorul specificat este în prezent nedefinit. Oricare dintre aceste directive poate fi urmată de un număr arbitrar de linii de text, care poate conține declarația #else (#elif nu poate fi utilizat) și se termină cu #endif. Dacă condiția bifată este adevărată, atunci toate liniile dintre #else și #endif sunt ignorate, iar dacă este falsă, atunci liniile dintre check și #else (dacă nu există cuvântul #else, atunci #endif). Directivele #If și #ifndef pot fi imbricate una în alta.

Consultați directiva

#undef identificator

duce la faptul că identificatorul specificat începe să fie considerat nedefinit, adică nu poate fi înlocuit.

Să ne uităm la câteva exemple. Următoarele trei directive sunt:

verificați dacă identificatorul WRITE este definit (adică, a existat o comandă precum #define WRITE ...) și, dacă da, atunci numele WRITE începe să fie considerat nedefinit, adică nu poate fi înlocuit.

Directivele

#define WRITE fprintf

verifică dacă identificatorul WRITE este nedefinit și, dacă da, identificatorul WRITE este definit în locul numelui fprintf.

Directiva #error este scrisă în următoarea formă:

#error_message message

Dacă se găsește în textul programului, atunci compilarea se oprește și un mesaj de eroare este afișat pe ecranul de afișare. Această comandă este utilizată în principal în faza de depanare. Rețineți că nu este necesar să includeți mesajul de eroare între ghilimele duble.

Directiva #line este destinată să schimbe valorile variabilelor _LINE_ și _FILE_ definite în sistemul de programare C. Variabila _LINE_ conține numărul de linie al programului în curs de executare. Identificatorul _FILE_ este un pointer către un șir cu numele programului compilat. Directiva #line este scrisă după cum urmează:

#line number "file name"

Aici numărul este orice număr întreg pozitiv care va fi atribuit variabilei _LINE_, numele fișierului este un parametru opțional care suprascrie valoarea _FILE_.

Directiva #pragma vă permite să dați compilatorului câteva instrucțiuni. De exemplu, linia

indică faptul că programul C conține linii în limbaj de asamblare. De exemplu:

Să luăm în considerare niște identificatori globali sau nume de macrocomenzi (nume ale definițiilor macrocomenzilor). Sunt definite cinci astfel de nume: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Două dintre ele (_LINE_ și _FILE_) au fost deja descrise mai sus. Identificatorul _DATE_ definește un șir care stochează data la care fișierul sursă a fost tradus în cod obiect. Identificatorul _TIME_ specifică un șir care stochează timpul de traducere al fișierului sursă în codul obiect. Macrocomanda _STDC_ are o valoare de 1 dacă se utilizează nume de macrocomenzi definite standard. În caz contrar, această variabilă nu va fi definită.