Preprocesory sú programy, ktoré spracujú zdrojový kód pred začiatkom samotnej kompilácie. Nie sú súčasťou procesu kompilácie, ale fungujú samostatne a umožňujú programátorom upraviť kód pred kompiláciou.

previesť int na reťazec

• Je to prvý krok, ktorým prechádza zdrojový kód C pri konverzii na spustiteľný súbor.
• Hlavné typy predprocesorových direktív sú  Makrá Podmienená kompilácia zahrnutia súboru a ďalšie smernice ako #undef #pragma atď.
• Tieto smernice sa používajú hlavne na nahradenie danej časti kódu C iným kódom C. Napríklad, ak napíšeme '#define PI 3.14', potom je PI nahradený 3.14 preprocesorom.

Typy C preprocesorov

Všetky vyššie uvedené preprocesory možno rozdeliť do 4 typov:

Makrá

Makrá sa používajú na definovanie konštánt alebo vytváranie funkcií, ktoré sú nahradené preprocesorom pred kompiláciou kódu. Dva preprocesory #definovať a #undef sa používajú na vytváranie a odstraňovanie makier v jazyku C.

#definovať symbolickú hodnotu
#undef žetón

kde po predspracovaní žetón sa rozšíri na jeho hodnotu v programe.

Príklad:

#include  // Macro Definition #define LIMIT 5 int main(){  for (int i = 0; i < LIMIT; i++) {  printf('%d n' i);  }  return 0; } 

0 1 2 3 4 

Vo vyššie uvedenom programe sa pred začiatkom kompilácie slovo LIMIT nahrádza číslom 5. Slovo 'LIMIT' v definícii makra sa nazýva makro šablóna a „5“ je makro expanzia.

Poznámka Na konci definície makra nie je bodkočiarka (;). Makro definície nepotrebujú na koniec bodkočiarku.

Nájdu sa aj nejaké Preddefinované makrá v C ktoré sú užitočné pri poskytovaní rôznych funkcií nášmu programu.

Makro definované predtým je možné zrušiť pomocou #undef preprocesora. Napríklad vo vyššie uvedenom kóde

#include  // Macro Definition #define LIMIT 5 // Undefine macro #undef LIMIT int main(){  for (int i = 0; i < LIMIT; i++) {  printf('%d n' i);  }  return 0; } 

výstup:

./Solution.c: In function 'main': ./Solution.c:13:28: error: 'MAX' undeclared (first use in this function) printf('MAX is: %dn' MAX); ^ ./Solution.c:13:28: note: each undeclared identifier is reported only once for each function it appears in

Makrá s argumentmi

Argumenty môžeme odovzdať aj makrám. Tieto makrá fungujú podobne ako funkcie. Napríklad

# definovať foo(a b) a + b
#define func(r) r * r

tostring java

Pochopme to pomocou programu:

#include  // macro with parameter #define AREA(l b) (l * b) int main(){  int a = 10 b = 5;    // Finding area using above macro  printf('%d' AREA(a b));  return 0; } 

Area of rectangle is: 50 

Vysvetlenie: Vo vyššie uvedenom programe makro OBLAST (l b) je definovaný na výpočet plochy obdĺžnika jeho vynásobením dĺžka (l) a šírka (b) . Kedy OBLAST (a b) sa nazýva expanduje do (a * b) a výsledok sa vypočíta a vytlačí.

Prosím, pozrite sa Typy makier v C pre viac príkladov a typov.

Zahrnutie súboru

Zahrnutie súboru vám umožňuje zahrnúť externé súbory (knižnice súborov hlavičiek atď.) do aktuálneho programu. To sa zvyčajne vykonáva pomocou #include Direktíva, ktorá môže obsahovať systémové aj užívateľom definované súbory.

Syntax

Existujú dva spôsoby, ako zahrnúť hlavičkové súbory.

#include
#include 'názov súboru'

The '<' a '>' zátvorky povedzte kompilátoru, aby vyhľadal súbor v štandardný adresár zatiaľ čo dvojité úvodzovky ( ' ) povedzte kompilátoru, aby vyhľadal hlavičkový súbor v adresári zdrojového súboru.

Príklad:

python znížiť

// Includes the standard I/O library #include   int main() {  printf('Hello World');    return 0; } 

Hello World

Podmienená kompilácia

Podmienená kompilácia umožňuje zahrnúť alebo vylúčiť časti kódu v závislosti od určitých podmienok. Je to užitočné pri vytváraní kódu špecifického pre platformu alebo pri ladení. Existujú nasledujúce podmienené direktívy preprocesora: #if #ifdef #ifndef else #elif a #endif

Syntax

Všeobecná syntax podmienených preprocesorov je:

#ak
// nejaký kód
#elif
// ešte nejaký kód
#else
// Ešte nejaký kód
#endif

Direktíva #endif sa používa na uzavretie #if #ifdef a #ifndef otváracích direktív.

Príklad

#include  // Defining a macro for PI #define PI 3.14159 int main(){   // Check if PI is defined using #ifdef #ifdef PI  printf('PI is definedn'); // If PI is not defined check if SQUARE is defined #elif defined(SQUARE)  printf('Square is definedn'); // If neither PI nor SQUARE is defined trigger an error #else  #error 'Neither PI nor SQUARE is defined' #endif // Check if SQUARE is not defined using #ifndef #ifndef SQUARE  printf('Square is not defined'); // If SQUARE is defined print that it is defined #else  printf('Square is defined'); #endif  return 0; } 

PI is defined Square is not defined

Vysvetlenie: Tento kód používa podmienené direktívy preprocesora ( #ifdef #elif a #ifndef ), aby ste skontrolovali, či určité makrá ( PI a SQUARE ) sú definované. Keďže PI je definované, program vypíše ' PI je definovaný ' potom skontroluje, či nie je definovaný SQUARE a vytlačí ' Štvorec nie je definovaný '.

iné smernice

Okrem direktív primárneho preprocesora C poskytuje aj ďalšie direktívy na správu správania kompilátora a ladenie.

#pragma:

Poskytuje špecifické inštrukcie pre kompilátor na kontrolu jeho správania. Používa sa na zakázanie nastavenia zarovnania varovaní atď.

Syntax

#pragma smernice

enkapsulačný program

Niektoré zo smerníc #pragma sú popísané nižšie: 

1. #pragma startup: Tieto direktívy nám pomáhajú špecifikovať funkcie, ktoré je potrebné spustiť pred spustením programu (predtým, ako riadenie prejde na main()).
2. #pragma exit : Tieto direktívy nám pomáhajú špecifikovať funkcie, ktoré sú potrebné na spustenie tesne pred ukončením programu (tesne predtým, ako sa ovládací prvok vráti z main()).

Príklad

#include  void func1(); void func2(); // specifying funct1 to execute at start #pragma startup func1 // specifying funct2 to execute before end #pragma exit func2 void func1() { printf('Inside func1()n'); } void func2() { printf('Inside func2()n'); } int main(){  void func1();  void func2();  printf('Inside main()n');  return 0; } 

Inside main() 

Vyššie uvedený kód vytvorí výstup uvedený vyššie pri spustení na kompilátoroch GCC, zatiaľ čo očakávaný výstup bol:

Očakávaný výstup

Inside func1() Inside main() Inside func2() 

Stáva sa to preto, že GCC nepodporuje spustenie alebo ukončenie #pragma. Môžete však použiť nižšie uvedený kód pre očakávaný výstup na kompilátoroch GCC. 

#include  void func1(); void func2(); void __attribute__((constructor)) func1(); void __attribute__((destructor)) func2(); void func1() {  printf('Inside func1()n'); } void func2() {  printf('Inside func2()n'); } int main() {  printf('Inside main()n');  return 0; } 

Inside func1() Inside main() Inside func2() 

Vo vyššie uvedenom programe sme použili niektoré špecifické syntaxe tak, že jedna z funkcií sa vykoná pred hlavnou funkciou a druhá sa vykoná po hlavnej funkcii.