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

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:

#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 

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.

hashtable versus hashmap

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:

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

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

#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

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: 

1. #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).
2. #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

#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() 

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. 

#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() 

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.