C PREDPROCESORY

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.

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  ;   }

Výstup

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  
 
  Pochopme to pomocou programu:  
 C      #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  ;   }   
    
  Výstup   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:    
 C      // Includes the standard I/O library   #include            int     main  ()     {      printf  (  'Hello World'  );          return     0  ;   }   
    
  Výstup   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    
 C      #include         // Defining a macro for PI   #define PI 3.14159   int     main  (){       // Check if PI is defined using #ifdef   #ifdef PI      printf  (  'PI is defined  n  '  );   // If PI is not defined check if SQUARE is defined   #elif defined(SQUARE)      printf  (  'Square is defined  n  '  );   // 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  ;   }   
    
  Výstup   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  
 
  Niektoré zo smerníc #pragma sú popísané nižšie:   
      #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()).  
     #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    
 C      #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  ;   }   
    
  Výstup   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.   
 C      #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  ;   }   
    
  Výstup   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.  
         Vytvoriť kvíz