Priekšapstrādātāji ir programmas, kas apstrādā avota kodu pirms faktiskās kompilācijas sākuma. Tie nav daļa no kompilācijas procesa, bet darbojas atsevišķi, ļaujot programmētājiem modificēt kodu pirms kompilācijas.

• Tas ir pirmais solis, ko veic C avota kods, kad tas tiek pārveidots izpildāmā failā.
• Galvenie priekšapstrādātāju direktīvu veidi ir  Makro Failu iekļaušanas nosacījuma kompilācija un citas direktīvas, piemēram, #undef #pragma utt.
• Šīs direktīvas galvenokārt tiek izmantotas, lai noteiktu C koda sadaļu aizstātu ar citu C kodu. Piemēram, ja mēs rakstām “#define PI 3.14”, tad priekšapstrādātājs PI aizstāj ar 3.14.

C priekšapstrādātāju veidi

Visus iepriekš minētos priekšapstrādātājus var iedalīt 4 veidos:

pārvērst par virkni java

Makro

Makro tiek izmantoti, lai definētu konstantes vai izveidotu funkcijas, kuras pirms koda kompilēšanas aizvieto priekšapstrādātājs. Divi priekšapstrādātāji #definēt un #undef tiek izmantoti, lai izveidotu un noņemtu makro C.

#definēt marķiera vērtība
#undef žetons

kur pēc pirmapstrādes žetons tiks paplašināts līdz tā vērtību programmā.

Piemērs:

#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 

Iepriekš minētajā programmā pirms kompilācijas sākuma vārds LIMIT tiek aizstāts ar 5. Vārds 'LIMIT' makro definīcijā sauc par makro veidni un "5" ir makro izvēršana.

Piezīme Makro definīcijas beigās nav semikola (;). Makro definīciju beigās nav nepieciešams semikāls.

Ir arī daži Iepriekš definēti makro C kas ir noderīgi, lai mūsu programmai nodrošinātu dažādas funkcijas.

Iepriekš definētu makro var nedefinēt, izmantojot #undef priekšapstrādātāju. Piemēram, iepriekš minētajā kodā

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

Izvade:

./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

Makro ar argumentiem

Argumentus varam nodot arī makro. Šie makro darbojas līdzīgi kā funkcijas. Piemēram

# definēt foo(a b) a + b
#define func(r) r * r

Ļaujiet mums to saprast ar programmu:

#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 

Paskaidrojums: Iepriekš minētajā programmā makro AREA(l b) ir definēts, lai aprēķinātu taisnstūra laukumu, reizinot tā laukumu garums (l) un platums (b) . Kad APJOMS(a b) sauc tas izplešas līdz (a * b) un rezultāts tiek aprēķināts un izdrukāts.

Lūdzu, skatiet Makro veidi C vairāk piemēru un veidu.

Failu iekļaušana

Failu iekļaušana ļauj pašreizējā programmā iekļaut ārējos failus (galvenes failu bibliotēkas utt.). Tas parasti tiek darīts, izmantojot #iekļauts direktīva, kas var ietvert gan sistēmas, gan lietotāja definētus failus.

Sintakse

Ir divi veidi, kā iekļaut galvenes failus.

#iekļauts
#iekļauts 'faila nosaukums'

The '<' un '>' iekavas sakiet kompilatoram meklēt failu mapē standarta direktorijs kamēr pēdiņas ( ' ' ) sakiet kompilatoram meklēt galvenes failu avota faila direktorijā.

Piemērs:

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

Hello World

Nosacītā kompilācija

Nosacīta kompilācija ļauj iekļaut vai izslēgt koda daļas atkarībā no noteiktiem nosacījumiem. Tas ir noderīgi, lai izveidotu platformas kodu vai atkļūdotu. Ir šādas nosacījuma priekšapstrādātāja direktīvas: #if #ifdef #ifndef else #elif un #endif

Sintakse

string.format java

Nosacītu priekšapstrādātāju vispārējā sintakse ir šāda:

#ja
// kāds kods
#elifs
// vēl kāds kods
#cits
// Vēl kāds kods
#endif

#endif direktīva tiek izmantota, lai aizvērtu #if #ifdef un #ifndef atvēršanas direktīvas.

Piemērs

#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

Paskaidrojums: Šis kods izmanto nosacījumu priekšapstrādātāja direktīvas ( #ifdef #elif un #ifndef ), lai pārbaudītu, vai noteikti makro ( PI un LAUKTS ) ir definēti. Tā kā PI ir definēts, programma drukā PI ir definēts Pēc tam pārbauda, ​​vai laukums SQUARE nav definēts, un izdrukā Kvadrāts nav definēts '.

Citas direktīvas

Papildus primārajām priekšapstrādātāju direktīvām C nodrošina arī citas direktīvas, lai pārvaldītu kompilatoru darbību un atkļūdošanu.

#pragma:

Sniedz īpašus norādījumus kompilatoram, lai kontrolētu tā uzvedību. To izmanto, lai atspējotu brīdinājumu iestatījumu izlīdzināšanu utt.

Sintakse

#pragma direktīva

Dažas no #pragma direktīvām ir aplūkotas tālāk: 

1. #pragma startēšana: Šīs direktīvas palīdz mums norādīt funkcijas, kas ir jāpalaiž pirms programmas palaišanas (pirms vadīkla tiek nodota main()).
2. #pragma izeja : šīs direktīvas palīdz mums norādīt funkcijas, kuras ir jāizpilda tieši pirms programmas iziešanas (tieši pirms vadīklas atgriešanās no main()).

Piemērs

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

Iepriekš minētais kods radīs izvadi, kā norādīts iepriekš, ja tiks palaists GCC kompilatoros, kamēr paredzamā izvade bija:

Paredzamā izvade

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

Tas notiek tāpēc, ka GCC neatbalsta #pragma startēšanu vai iziešanu. Tomēr GCC kompilatoru paredzamajai izvadei varat izmantot tālāk norādīto kodu. 

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

Iepriekš minētajā programmā mēs esam izmantojuši dažus specifiskas sintakses lai viena no funkcijām izpildītos pirms galvenās funkcijas, bet otra pēc galvenās funkcijas.

robeža, izmantojot css