Direcția #define specifică identificatorul și secvența de caractere la care va fi stocat acest identificator atunci când este găsit în textul programului. Identificatorul se numește și numele macro-ului, iar procesul de substituire se numește substituție macro. Forma standard a directivei este următoarea:
# definește secvența de caractere macro
Rețineți că în această declarație nu există punct și virgulă. Pot exista un număr de spații între identificator și secvența de caractere. Macroul se termină numai prin trecerea la o nouă linie.
De exemplu, dacă doriți să utilizați TRUE pentru o valoare de 1 și FALSE pentru 0, puteți declara următoarele două macrocomenzi:
#define TRUE 1
#define FALSE 0
Ca rezultat, în cazul în care compilatorul găsește TRUE sau FALSE în textul programului, acesta le va înlocui cu 1 și respectiv 0. De exemplu, următoarea linie afișează "0 1 2":
printf ("...", FALSE, TRUE, TRUE + 1);
Dacă este definită macrocomanda, aceasta poate fi utilizată pentru a defini alte macrocomenzi. De exemplu, următorul cod compară valorile numerice cu numele ONE, TWO și THREE:
#define ONE 1
#definirea DOUĂ ONE + ONE
#def ine THREE ONE + DOUA
Ca rezultat al substituției macro, identificatorii sunt înlocuiți de șirurile specificate. Dacă trebuie să definiți un mesaj de eroare standard, puteți scrie ceva de genul:
#define E_MS "Eroare standard la intrare. \ n"
/ *. * /
printf (E_MS);
Dacă compilatorul găsește identificatorul E_MS, îl înlocuiește cu șirul "Eroare standard la intrare". De fapt, compilatorul vede operatorul sub forma
printf ("Eroare standard la introducere. \ n");
Dacă identificatorul se află în șir, atunci nu apare nicio substituire. De exemplu:
#define XYZ acesta este un test
/ *. * /
printf ("XYZ");
nu va ieși "acesta este un test", ci "XYZ".
Dacă șirul nu se potrivește pe o singură linie, atunci se poate continua pe linia următoare, plasând capătul liniei backslash așa cum se arată în exemplul următor:
#define LONG_STRING "Aceasta este o lungă perioadă de timp" \
șir care este folosit ca exemplu. "
Programatorii care scriu în C folosesc frecvent litere mari pentru a identifica identificatorii. Acest acord ajută orice persoană care citește programul, aruncând o privire la ea, aflând că are de-a face cu o macrocomandă. De asemenea, este mai bine să puneți #define la începutul fișierului sau chiar într-un fișier antet separat.
Foarte des, macro-urile sunt folosite pentru a determina "numerele magice" folosite în program. De exemplu, un program poate defini o matrice și poate avea mai multe proceduri pentru a lucra cu ea. În loc să codificați dimensiunea matrice, pentru a defini mai bine macro, dimensiunea, respectiv-corespunzătoare de matrice, și să-l utilizați în locuri unde este necesar să se utilizeze timp măsuri. Astfel, dacă doriți să modificați dimensiunea de matrice, singurul lucru ce trebuie să faceți - este de a schimba declarația #define și recompilați programul. Oriunde a fost utilizată această macrocomandă, vor apărea modificări automate. Să luăm în considerare un exemplu:
#define MAX_SIZE 100
/ *. * /
soldul de flotare [MAX_SIZE];
/ *. * /
timpul de flotare [MAX_SIZE];
Pentru a redimensiona ambele matrice, modificați doar definiția MAX_SIZE.
Direcția #define are încă o posibilitate: o macrocomandă poate avea argumente. De fiecare dată când se întâlnește această macrocomandă, argumentele macro vor fi înlocuite de argumentele reale ale programului. Acest tip de macro este numit tip de funcție macro. De exemplu:
#include
#definiti MIN (a, b) ((a)<(b)). (a). (b)
int principal (void)
int x, y;
x = 10; y = 20;
printf ("Minima este :.", MIN (x, y));
retur 0;
>
La compilarea unui program, în loc de MIN (a, b), expresia specificată este înlocuită și în loc de parametrii fictivi a și b, x și y sunt înlocuite. Astfel, ca urmare a funcției de substituție printf () va avea următoarea formă:
printf ("Minimul este :.", ((x) <(y) ). (x). (y) );
Trebuie să fii atent atunci când definesc macro-urile care primesc argumente sau poți obține niște rezultate neașteptate. De exemplu, luați în considerare următorul program scurt care utilizează o macrocomandă pentru a determina paritatea unei valori:
/ * programul produce rezultatul greșit * /
#include
#define EVEN (a) a% 2 == 0. 1. 0
int principal (void)
if (EVEN (9 + 1)) printf ( "este chiar");
altceva printf ("este ciudat");
retur 0;
>
Din cauza metodei de substituire, acest program nu funcționează corect. Ca urmare, programul de compilare CHIAR (9 + 1) pentru a extinde
După cum se știe, operatorul de preluare prin modul are o prioritate mai mare decât operatorul cuvântului-salt. Aceasta înseamnă că veți lua mai întâi un modulo cu numărul 1 și apoi rezultatul va fi adăugat la 9, care, firește, nu poate fi 0. Pentru a elimina această problemă, trebuie să închideți macro-ul EVEN în paranteze, după cum se arată în următoarea versiunea corectă a programului:
#include
#define EVEN (a) (a)% 2 == 0. 1. 0
int principal (void)
dacă (EVEN (9 + 1)) printf ("este egal");
altceva printf ("este ciudat");
retur 0;
>
Observăm că 9 + 1 este calculat înainte de a lua modulo. În general, încheierea parametrilor macro în paranteze este o idee suficient de bună și evită multe probleme.
Folosind substituirea macro în loc de funcții reale de avantajul unui singur mare TION lui - crește în mod semnificativ viteza de program, deoarece nu este nevoie de a pierde timpul pe un apel de funcție și să se întoarcă de la ea. Cu toate acestea, pentru această creștere a vitezei ar trebui să plătească o creștere a dimensiunii codului executabil al programului, din moment ce programe ma forțat să duplicat codul macro.
Articole similare
Trimiteți-le prietenilor: