C ELŐFELDOLGOZÓK

Előfeldolgozók olyan programok, amelyek a tényleges fordítás megkezdése előtt feldolgozzák a forráskódot. Nem részei a fordítási folyamatnak, de külön működnek, így a programozók módosíthatják a kódot a fordítás előtt.

Ez az első lépés, amelyen a C forráskód végrehajtható fájllá konvertálásakor megy keresztül.
Az előfeldolgozói irányelvek fő típusai a következők Makrók Fájlbefoglalás feltételes fordítás és egyéb direktívák, például #undef #pragma stb.
Főleg ezek az irányelvek arra szolgálnak, hogy a C kód adott szakaszát egy másik C kóddal helyettesítsék. Például, ha azt írjuk, hogy „#define PI 3.14”, akkor az előfeldolgozó a PI-t 3.14-re cseréli.

A C előfeldolgozók típusai

Az összes fenti előfeldolgozó 4 típusba sorolható:

Makrók

Makrók konstansok definiálására vagy olyan függvények létrehozására használatosak, amelyeket az előfeldolgozó helyettesít a kód lefordítása előtt. A két előfeldolgozó #define és #undef makrók létrehozására és eltávolítására szolgálnak C-ben.

#define token érték
#undef jelképes

ahol az előfeldolgozás után a jelképes annak kibővül érték a programban.

Példa:

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

Kimenet

0 1 2 3 4

A fenti programban a fordítás megkezdése előtt a LIMIT szó helyére 5 kerül. A szó 'HATÁR' a makródefinícióban makró sablonnak nevezzük és Az '5' a makro bővítés.

Jegyzet A makródefiníció végén nincs pontosvessző (;). A makródefinícióknak nincs szükségük pontosvesszőre a végén.

Vannak olyanok is Előre meghatározott makrók C-ben amelyek hasznosak programunk különféle funkcióinak biztosításához.

A korábban definiált makró definiálása visszavonható az #undef előfeldolgozóval. Például a fenti kódban

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

Kimenet:

 ./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ók érvekkel  
  A makróknak is átadhatunk argumentumokat. Ezek a makrók a függvényekhez hasonlóan működnek.     Például    
   #     meghatározni    foo(a b) a + b   
 #define func(r) r * r  
 
  Értsük meg ezt egy programmal:  
 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  ;   }   
    
  Kimenet   Area of rectangle is: 50  
     Magyarázat:    A fenti programban a makró     TERÜLET(l b)    úgy van definiálva, hogy egy téglalap területét a szorzatával számítja ki     hossza (l)    és     szélesség (b)    . Amikor     TERÜLET(a b)    úgy hívják, hogy kitágul     (a * b)    és az eredményt kiszámolja és kinyomtatja.  
  Kérjük, olvassa el    A makrók típusai C-ben    további példákért és típusokért.  
  Fájlfelvétel  
  A fájlbefoglalás lehetővé teszi külső fájlok (fejlécfájl-könyvtárak stb.) felvételét az aktuális programba. Ez általában a     #beleértve    direktíva, amely rendszer- és felhasználó által definiált fájlokat is tartalmazhat.  
     Szintaxis    
  A fejlécfájlok beillesztésének két módja van.  
      #beleértve        
    #beleértve    'fájlnév'  
 
  A     ' <'     és     '>' zárójelben    mondd meg a fordítónak, hogy keresse meg a fájlt a     szabványos könyvtár    míg     idézőjelek ( ' ' )    mondja meg a fordítónak, hogy keresse meg a fejlécfájlt a forrásfájl könyvtárában.  
     Példa:    
 C      // Includes the standard I/O library   #include            int     main  ()     {      printf  (  'Hello World'  );          return     0  ;   }   
    
  Kimenet   Hello World 
     Feltételes összeállítás    
    Feltételes összeállítás    lehetővé teszi a kód egyes részeinek felvételét vagy kizárását bizonyos feltételektől függően. Ez hasznos platform-specifikus kód létrehozásához vagy hibakereséshez. A következő feltételes előfeldolgozó utasítások vannak: #if #ifdef #ifndef else #elif és #endif  
     Szintaxis    
  A feltételes előfeldolgozók általános szintaxisa a következő:  
      #ha     
 // valami kód   
    #elif     
 // még néhány kód   
    #más     
 // Még néhány kód   
    #endif    
 
  Az #endif direktíva az #if #ifdef és az #ifndef nyitó direktívák lezárására szolgál.  
     Példa    
 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  ;   }   
    
  Kimenet   PI is defined Square is not defined 
     Magyarázat:    Ez a kód feltételes előfeldolgozó direktívákat használ (     #ifdef #elif és #ifndef    ) ellenőrizni, hogy bizonyos makrók (     PI    és     NÉGYZET    ) vannak meghatározva. Mivel a PI definiálva van, a program kiírja     A PI meg van határozva    ' ezután ellenőrzi, hogy a SQUARE nincs-e definiálva, és kiírja a     A négyzet nincs meghatározva    '.  
  Egyéb irányelvek  
  Az elsődleges előfeldolgozó direktívákon kívül a C más direktívákat is biztosít a fordítói viselkedés és a hibakeresés kezelésére.  
  #pragma:  
  Konkrét utasításokat ad a fordítónak a viselkedésének szabályozására. A figyelmeztetések beállításának letiltására szolgál stb.  
     Szintaxis    
      #pragma    irányelv  
 
  Néhány #pragma irányelvet az alábbiakban tárgyalunk:   
      #pragma startup:    Ezek az utasítások segítenek meghatározni azokat a függvényeket, amelyek futtatásához szükségesek a program indítása előtt (mielőtt a vezérlő átmenne a main()-ba).  
     #pragma kilépés    : Ezek a direktívák segítenek meghatározni azokat a függvényeket, amelyek futtatásához közvetlenül a program kilépése előtt (közvetlenül azelőtt, hogy a vezérlő visszatér a main()-ból) kell futni.  
 
     Példa    
 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  ;   }   
    
  Kimenet   Inside main()  
  A fenti kód a fentiek szerint állítja elő a kimenetet, ha GCC fordítókon fut, miközben a várt kimenet a következő volt:  
     Várható kimenet    
  Inside func1() Inside main() Inside func2()    Ez azért történik, mert a GCC nem támogatja a #pragma indítást vagy kilépést. Azonban használhatja az alábbi kódot a várt kimenethez a GCC fordítókon.   
 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  ;   }   
    
  Kimenet   Inside func1() Inside main() Inside func2()  
  A fenti programban néhányat használtunk    meghatározott szintaxisok    úgy, hogy az egyik függvény a főfunkció előtt, a másik pedig a főfüggvény után.  
         Kvíz létrehozása