Vad ingår i c. Direktiven om förprocessorer

Operatör # en texttoken i en citerad sträng. Låt oss se ett exempel:

#omfatta använder namnrymd std; #define message (s) cout<< "Сообщение: " #s << endl; int main() { message("GunGame"); return 0; }

Sammankoppla strängar och expandera meddelandemakrot till cout<< "Сообщение: GunGamen"; . Обратите внимание на то, что операция # должна использоваться совместно с аргументами, так как # ссылается на аргумент.

Makrooperatör ##

Operatören ## tar två separata tokens och limmer ihop dem för att bilda ett makro. Resultatet kan vara ett variabelnamn, klassnamn eller någon annan identifierare. Till exempel:

#definiera typ ch ## ar typ a; // variabel a är datatyp char, eftersom ch och ar är limmade i char

Låt oss överväga ett annat exempel på att använda ## -operatören, där vi kombinerar två tokens:

#define TOKENCONCAT (x, y) x ## y

När ett program anropar detta makro kombineras de två tokens till ett. Operation ## måste ha två operander.

PS.: Alla seriösa program måste ha en egen databas, vanligtvis används följande DBMS för att hantera databasen: MySQL, MsSQL, PostgreeSQL, Oracle, etc. När du installerar SQL Server kommer forumet på cyberforum.ru att vara en ersättningsbar assistent för du. Ställ dina frågor på detta forum, du kommer definitivt att få hjälp med att lösa ditt problem.

En förprocessor är ett speciellt program som ingår i C-kompilatorn. Den är avsedd för förbehandling av programtexten. Förprocessorn låter dig inkludera filer i programtexten och ange makrodefinitioner.
Förprocessorn arbetar med hjälp av speciella direktiv (instruktioner). De är markerade med en hash #. I slutet av raderna som anger direktiv på C-språket kan semikolonet utelämnas.

Grundläggande förbehandlingsdirektiv

#include - infogar text från den angivna filen
#define - definierar en makrodefinition (makro) eller symbolisk konstant
#undef - ångra den tidigare definitionen
#if - utför villkorlig sammanställning om ett konstant uttryck är sant
#ifdef - utför villkorlig sammanställning när en symbolisk konstant definieras
#ifndef - utför villkorlig sammanställning när symbolisk konstant är odefinierad
#else - gren av villkorlig sammanställning om uttrycket är falskt
#elif - villkorlig sammanställningsgren bildad genom att slå ihop annat och if
#endif - slutet på den villkorliga sammanställningsgrenen
#line - preprocessor ändrar det aktuella radnumret och namnet på den kompilerade filen
#error - utfärdar ett diagnosmeddelande
#pragma är en åtgärd som beror på en specifik implementering av kompilatorn.

#Inkludera direktivet

#Include-direktivet låter dig inkludera den angivna filen i programtexten. Om filen är ett standardbibliotek och finns i kompileringsmappen, är den innesluten i vinkelparenteser<> .
Om filen finns i den aktuella projektkatalogen anges den med citattecken "". För en fil som finns i en annan katalog måste du ange hela sökvägen i citattecken.

#omfatta
# inkludera "func.c"

# Definiera direktivet

I #define-direktivet kan du ange konstanter och makrodefinitioner i programtexten.
Allmän anmälningsform

#define Id Replacement

1
2
3
4
5
6
7
8

#omfatta
#definiera A 3
int main ()
{
printf ("% d +% d =% d", A, A, A + A); // 3 + 3 = 6
getchar ();
returnera 0;
}

Kompilatorn tilldelar en eller annan typ till den beroende på konstantens värde. Med hjälp av suffix kan du åsidosätta typen av en konstant:

• U eller u representerar en osignerad heltalskonstant;
• F (eller f) låter dig beskriva en verklig konstant av typen float;
• L (eller l) låter dig allokera en heltalskonstant 8 byte (lång int);
• L (eller l) låter dig beskriva en riktig konstant av typen long double

#define A 280U // osignerad int
#define B 280LU // osignerad lång int
#define C 280 // int (long int)
#define D 280L // lång int
#define K 28.0 // double
#define L 28.0F // float
#define M 28.0L // lång dubbel

Den andra formen av syntax definierar ett funktionsliknande makro med parametrar. Det här formuläret tillåter en valfri lista med parametrar som måste vara inom parentes. Efter att ha definierat ett makro, varje efterföljande förekomst

identifierare (arg1, ..., argn)

C-exempel: Beräkning av sinus för en vinkel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#omfatta
#omfatta
#omfatta
#define PI 3.14159265
#define SIN (x) sin (PI * x / 180)
int main ()
{
int c;
system ("chcp 1251");
system ("cls");
printf ( "Ange vinkeln i grader:");
scanf ("% d", & c);
printf ("sin (% d) =% lf", c, SIN (c));
getchar (); getchar ();
returnera 0;
}

Utförande resultat

Skillnaden mellan sådana makron och funktioner i C-språket är att i sammanställningsfasen ersätts varje förekomst av identifieraren med motsvarande kod. Således kan ett program ha flera kopior av samma kod som motsvarar en identifierare. Om du arbetar med funktioner kommer programmet att innehålla 1 kopia av koden som implementerar den angivna funktionen, och varje gång funktionen kallas till kommer kontrollen att överföras till den.
Du kan avbryta makrodefinitionen med #undef-direktivet.

Man bör dock vara försiktig när man till exempel använder sådana makron

1
2
3
4
5
6
7
8
9
10
11
12
13

#omfatta
#define sum (A, B) A + B
int main ()
{
int a, b, c, d;
a = 3; b = 5;


getchar ();
returnera 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#omfatta
#define sum (A, B) A + \
B
int main ()
{
int a, b, c, d;
a = 3; b = 5;
c = (a + b) * 2; // c = (a + b) * 2
d = summa (a, b) * 2; // d = a + b * 2;
printf ("a =% d \ n b =% d \ n", a, b);
printf ("c =% d \ n d =% d \ n", c, d);
getchar ();
returnera 0;
}

1
2
3
4
5
6
7
8
9

#omfatta
#define SUM (x, y) (a ## x + a ## y)
int main ()
{
int al = 5, a2 = 3;
printf ("% d", SUM (1, 2)); // (a1 + a2)
getchar ();
returnera 0;
}

Direktiven #if eller # ifdef / # ifndef, tillsammans med direktiven #elif, #else och #endif, styr sammanställningen av delar av källfilen.
Om det angivna uttrycket efter #if har ett icke-nollvärde sparas gruppen av rader direkt efter #if-direktivet i transformationsposten. Syntaxen för det villkorliga direktivet är som följer:

1
2
3
4
5
6
7

#om konstant uttryck
grupp av verksamheter
#elif konstant uttryck
grupp av verksamheter
#annan
grupp av verksamheter
#endif

Skillnaden mellan # ifdef / # ifndef-direktiv är att ett konstant uttryck bara kan ställas in med #define.

Varje #if-direktiv i källfilen måste ha ett motsvarande #endif-direktiv. Valfritt antal #elif-direktiv kan placeras mellan #if- och #endif-direktiv, men högst ett #else-direktiv är tillåtet. #Else-direktivet, om det finns, måste vara det sista före #endif-direktivet.

Exempel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#omfatta
#omfatta
#definiera P 2
int main ()
{
system ("chcp 1251");
system ("cls");
#om P == 1
printf ( "Gren 1 pågår");
#elif P == 2
printf ( "Gren 2 pågår, P =% d", P);
#annan
printf ( "En annan gren pågår, P =% d", P);
#endif
getchar ();
returnera 0;
}

Förprocessor det är bäst att betrakta som ett separat program som körs före kompilering. När programmet startar skannar förprocessorn koden uppifrån och ner, fil för fil och letar efter direktiv. DirektivÄr speciella kommandon som börjar med symbolen # och sluta INTE med semikolon. Det finns flera typer av direktiv som vi kommer att titta på nedan.

#Inkludera direktivet

Du har redan sett #include-direktivet i aktion. När du # inkluderar en fil kopierar förprocessorn innehållet i den inkluderade filen till den aktuella filen direkt efter #include-raden. Detta är mycket användbart när du använder vissa data (till exempel funktioner) på flera platser samtidigt.

Direktivet #include har två former:

#omfatta som säger till förprocessorn att leta efter filen i systemvägarna. Du använder oftast det här formuläret när du länkar från C ++ - standardbiblioteken.

#include "filnamn" som säger till förprocessorn att leta efter en fil i den aktuella projektkatalogen. Om det inte finns där kommer förprocessorn att börja kontrollera systemvägarna och alla andra som du angav i dina inställningar. Det här formuläret används för att inkludera anpassade rubrikfiler.

# Definiera direktivet

Direktivet #define kan användas för att skapa makron. Makro- detta är regeln som bestämmer omvandlingen av identifieraren till den angivna informationen.

Det finns två huvudtyper av makron: funktionsmakron och objektmakron.

Makrofunktioner beter sig som funktioner och används för samma ändamål. Vi kommer inte att diskutera dem nu, eftersom deras användning i allmänhet anses vara farlig, och nästan allt de kan göra kan göras med en enkel (linjär) funktion.

Makroobjekt kan bestämmas på något av följande två sätt:

#define identifier
#define identifierare substitution_text

Den övre definitionen har ingen substitution_text, medan den nedre har. Eftersom detta är förbehandlingsdirektiv (och inte enkla) slutar ingen av formerna med semikolon.

Makroobjekt med substitution_text

När förprocessorn stöter på makroobjekt med substitution_text ersätts varje ytterligare förekomst av identifierare med substitution_text. Identifieraren skrivs vanligtvis med stora bokstäver med understrykningar istället för mellanslag.

Tänk på följande kod:

#define MY_FAVORITE_NUMBER 9 std :: cout<< "My favorite number is: " << MY_FAVORITE_NUMBER << std::endl;

Förprocessorn konverterar koden ovan till:

std :: cout<< "My favorite number is: " << 9 << std::endl;

Varje ytterligare förekomst av USE_YEN-identifieraren tas bort och ersätts med "ingenting" (tomt utrymme)!

Detta kan verka ganska värdelöst, men detta är inte huvudsyftet med sådana direktiv. Till skillnad från objektmakron med substitution_text anses denna form av makron vara acceptabel.

Villkorlig sammanställning

Förbehandlingsdirektiven om villkorlig kompilering låter dig bestämma under vilka förhållanden koden kommer att sammanställas och under vilka förhållanden den inte kommer att göra. I den här handledningen tittar vi bara på tre villkorliga sammanställningsdirektiv:

#ifdef;

#ifndef;

#endif.

#Ifdef-direktivet(eng. " om def ined "=" om definierad ") tillåter förprocessorn att kontrollera om värdet tidigare var #define. Om så är fallet kommer koden mellan #ifdef och #endif att kompileras. Om inte, ignoreras koden. Till exempel:

#define PRINT_JOE #ifdef PRINT_JOE std :: cout<< "Joe" << std::endl; #endif #ifdef PRINT_BOB std::cout << "Bob" << std::endl; #endif

Eftersom PRINT_JOE redan var #define, std :: cout-linjen<< "Joe" << std::endl; скомпилируется и выполнится. А поскольку PRINT_BOB не был #define, то строчка std::cout << "Bob" << std::endl; не скомпилируется и, следовательно, не выполнится.

#Indef-direktivet(eng. " om n ot def ined "=" om inte definierat ") är den motsatta av #ifdef, som låter dig kontrollera om ett värde har definierats tidigare. Till exempel:

#ifndef PRINT_BOB std :: cout<< "Bob" << std::endl; #endif

Det här kodavsnittet returnerar Bob eftersom PRINT_BOB aldrig har varit #define förut. Villkorlig sammanställning används ofta som rubrikvakter (vi pratar om dem i nästa lektion).

Omfattningen av #define-direktivet

Direktiven körs innan programmet sammanställs: från topp till botten, fil för fil.

Tänk på följande program:

#omfatta void boo () (#define MY_NAME "Alex") int main () (std :: cout<< "My name is: " << MY_NAME; return 0; }

Även om #define MY_NAME "Alex" -direktivet definieras i boo-funktionen, kommer förprocessorn inte att märka detta eftersom den inte förstår C ++ -begrepp som funktioner. Därför kommer genomförandet av detta program att vara identiskt med det där #define MY_NAME "Alex" definierades FÖRE eller omedelbart EFTER boo-funktionen. För bättre kodläsbarhet, definiera identifierare (med #define) utanför funktionerna.

När förprocessorn är klar körs alla identifierare (definierade med #define) från den här filen. Detta innebär att direktiv endast är giltiga från definitionspunkten till slutet av filen där de definieras. Direktiv definierade i en kodfil påverkar inte direktiv som definierats i andra filer i samma projekt.

Tänk på följande exempel:

#omfatta ogiltig doSomething () (#ifdef PRINT std :: cout<< "Printing!"; #endif #ifndef PRINT std::cout << "Not printing!"; #endif }

Rubrikfiler ingår i programtexten med förbehandlingsdirektiven#omfatta. Förprocessordirektiv börjar med ett hash-tecken (#), vilket måste vara det allra första tecknet på raden. Programmet som hanterar dessa direktiv kallas förprocessor(i moderna kompilatorer är förprocessorn vanligtvis en del av själva kompilatorn).
#Include-direktivet innehåller innehållet i den angivna filen i programmet. Filnamnet kan anges på två sätt:

#omfatta # inkludera "min_fil.h"

Om filnamnet finns i vinkelparenteser (<>) antas att vi behöver en viss standardhuvudfil, och kompilatorn letar efter den här filen på fördefinierade platser. (Hur dessa platser definieras skiljer sig mycket från plattform till plattform och implementering till implementering.) Dubbla citat indikerar att rubrikfilen är en anpassad rubrikfil och söker efter den från den katalog där programmets källa finns.
Rubrikfilen kan också innehålla #include-direktiv. Därför är det ibland svårt att veta vilka specifika rubrikfiler som ingår i en given källkod, och vissa rubrikfiler kan inkluderas flera gånger. Låt undvika detta villkorliga förbehandlingsdirektiv... Låt oss överväga ett exempel:

#ifndef BOOKSTORE_H #define BOOKSTORE_H / * innehållet i bokhandeln.h-filen * / #endif

#Ifndef villkorliga direktivet kontrollerar om BOOKSTORE_H-värdet tidigare definierades. (BOOKSTORE_H är en förprocessorkonstant; sådana konstanter skrivs vanligtvis med stora bokstäver.) Förprocessorn bearbetar följande rader fram till #endif-direktivet. Annars hoppar den över raderna från #ifndef till # endif.
Direktiv

#define BOOKSTORE_H

definierar förprocessorkonstanten BOOKSTORE_H. Genom att placera detta direktiv direkt efter #ifndef-direktivet kan vi se till att innehållet i bookstore.h-rubrikfilen endast ingår i källtexten, oavsett hur många gånger själva filen ingår i texten.
Ett annat vanligt exempel på att använda villkorliga förprocessordirektiv är införandet av felsökningsinformation i programtexten. Till exempel:

Int main () (#ifdef DEBUG cout<< "Начало выполнения main()\n"; #endif string word; vectortext; while (cin >> word) (#ifdef DEBUG cout<< "Прочитано слово: " << word << "\n"; #endif text.push_back(word); } // ... }

Om DEBUG-konstanten inte är definierad kommer den resulterande programtexten att se ut så här:

Int main () (strängord; vektor text; medan (cin >> word) (text.push_back (word);) // ...)

Annars får vi:

Int main () (cout<< "Начало выполнения main()\n"; string word; vectortext; medan (cin >> word) (cout<< "Прочитано слово: " << word << "\n"; text.push_back(word); } // ... }

Förprocessorkonstanten kan specificeras på kommandoraden när kompilatorn anropas med alternativet -D (olika implementeringar kan kalla detta alternativ annorlunda). För UNIX-system ser kompilatoranropet med definitionen av förbehandlingskonstanten DEBUG så här ut:

$ CC -DDEBUG main.C

Det finns konstanter som automatiskt bestäms av kompilatorn. Vi kan till exempel ta reda på om vi sammanställer ett C ++ - eller C-program. För ett C ++ - program definieras __cplusplus-konstanten (två understrykningar) automatiskt. För standard C definieras __STDC__. Naturligtvis kan båda konstanterna inte definieras samtidigt. Exempel:

#idfef __cplusplus // kompilera ett C ++ - program externt "C"; // extern "C" förklaras i kapitel 7 #endif int main (int, int);

Andra användbara fördefinierade konstanter (i det här fallet är det bättre att säga variabler) av förprocessorn är __LINE__ och __FILE__. Variabeln __LINE__ innehåller numret på den kompilerade raden och __FILE__ är namnet på den kompilerade filen. Här är ett exempel på deras användning:

Om (element_count == 0) cerr<< "Ошибка. Файл: " << __FILE__ << " Строка: " << __LINE__ << "element_count не может быть 0";

De två konstanterna __DATE__ och __TIME__ innehåller sammanställningsdatum och tid.
C-standardbiblioteket tillhandahåller ett användbart makrotillstånd () som söker efter ett tillstånd och, om det misslyckas, ger ett diagnosmeddelande och avbryter programmet. Vi kommer att använda detta användbara makro ofta i efterföljande exempelprogram. För att använda det bör du inkludera direktivet i programmet

#omfatta

assert.h är C-standardbibliotekets rubrikfil. Ett C ++ - program kan hänvisa till en rubrikfil antingen med dess C-namn eller C ++ -namn. I C ++ - standardbiblioteket heter filen cassert. Namnet på rubrikfilen i C ++ - biblioteket skiljer sig från namnet på motsvarande fil för C på grund av frånvaron av .h-förlängningen och bokstaven c införd framför (det nämndes redan ovan att tillägg inte används i sidhuvudfiler för C ++, eftersom de kan bero på implementeringen).
Effekten av att använda #include preprocessor-direktivet beror på typen av huvudfilen. Instruktioner

#omfatta

innehåller innehållet i kassettfilen i programtexten. Men eftersom alla namn som används i C ++ - standardbiblioteket definieras i std-utrymme kommer namnet assert () att vara osynligt tills vi uttryckligen gör det synligt med följande med hjälp av direktivet:

Använda namespace std;

Om vi ​​tar med huvudfilen för C-biblioteket i programmet

#omfatta

då försvinner behovet av ett användningsdirektiv: namnet på assert () kommer att synas ändå. (Namnutrymmen används av biblioteksutvecklare för att förhindra att det globala namnutrymmet störs. I avsnitt 8.5 diskuteras detta ämne mer detaljerat.)