Les préprocesseurs sont des programmes qui traitent le code source avant la compilation. Plusieurs étapes sont impliquées entre l'écriture d'un programme et son exécution en C. Examinons ces étapes avant de commencer réellement à en apprendre davantage sur les préprocesseurs.
Vous pouvez voir les étapes intermédiaires dans le diagramme ci-dessus. Le code source écrit par les programmeurs est d'abord stocké dans un fichier, que le nom soit programme.c . Ce fichier est ensuite traité par des préprocesseurs et un fichier de code source étendu est généré nommé program.i. Ce fichier développé est compilé par le compilateur et un fichier de code objet est généré nommé program.obj. Enfin, l'éditeur de liens lie ce fichier code objet au code objet des fonctions de la bibliothèque pour générer le fichier exécutable program.exe.
Directives du préprocesseur en C
Les programmes de préprocesseur fournissent des directives de préprocesseur qui indiquent au compilateur de prétraiter le code source avant de le compiler. Toutes ces directives de préprocesseur commencent par un symbole « # » (dièse). Le symbole « # » indique que toute instruction commençant par un « # » sera envoyée au programme du préprocesseur pour être exécutée. Nous pouvons placer ces directives de préprocesseur n'importe où dans notre programme.
Voici des exemples de directives de préprocesseur : #inclure , #définir , #ifndef, etc.
Note Rappelez-vous que le # Le symbole fournit uniquement un chemin vers le préprocesseur et une commande telle que include est traitée par le programme du préprocesseur. Par exemple, #include inclura le code ou le contenu du fichier spécifié dans votre programme.
Liste des directives du préprocesseur en C
Le tableau suivant répertorie toutes les directives du préprocesseur en C :
| Directives du préprocesseur | Description |
|---|---|
| #définir | Utilisé pour définir une macro |
| #undef | Utilisé pour annuler la définition d'une macro |
| #inclure | Utilisé pour inclure un fichier dans le programme de code source |
| #ifdef | Utilisé pour inclure une section de code si une certaine macro est définie par #define |
| #ifndef | Utilisé pour inclure une section de code si une certaine macro n'est pas définie par #define |
| #si | Vérifier la condition spécifiée |
| #autre | Code alternatif qui s'exécute lorsque #if échoue |
| #fin si | Utilisé pour marquer la fin de #if, #ifdef et #ifndef |
Ces préprocesseurs peuvent être classés en fonction du type de fonction qu'ils exécutent.
Types de préprocesseurs C
Il existe 4 principaux types de directives de préprocesseur :
- Macro
- Inclusion de fichiers
- Compilation conditionnelle
- Autres directives
Découvrons maintenant chacune de ces directives en détail.
1. Macro
En C, les macros sont des morceaux de code dans un programme auquel on donne un nom. Chaque fois que ce nom est rencontré par le compilateur, celui-ci remplace le nom par le morceau de code réel. Le '#définir' La directive est utilisée pour définir une macro.
Syntaxe de la définition de macro
#define token value>
où après le prétraitement, le jeton sera étendu à son valeur dans le programme.
Exemple de macro
C
// C Program to illustrate the macro> #include> // macro definition> #define LIMIT 5> int> main()> {> >for> (>int> i = 0; i printf('%d
', i); } return 0; }> |
monliviricket
>
>Sortir
0 1 2 3 4>
Dans le programme ci-dessus, lorsque le compilateur exécute le mot LIMIT, il le remplace par 5. Le mot 'LIMITE' dans la définition de la macro s'appelle un modèle de macro et « 5 » est l’expansion macro.
Note Il n'y a pas de point-virgule (;) à la fin de la définition de la macro. Les définitions de macro n'ont pas besoin d'un point-virgule pour se terminer.
Il y a aussi quelques Macros prédéfinies en C qui sont utiles pour fournir diverses fonctionnalités à notre programme.
Macros avec arguments
Nous pouvons également passer des arguments aux macros. Les macros définies avec des arguments fonctionnent de la même manière que les fonctions.
Exemple
#define foo( a, b ) a + b #define func(r) r * r>
Comprenons cela avec un programme :
C
// C Program to illustrate function like macros> #include> // macro with parameter> #define AREA(l, b) (l * b)> int> main()> {> >int> l1 = 10, l2 = 5, area;> >area = AREA(l1, l2);> >printf>(>'Area of rectangle is: %d'>, area);> >return> 0;> }> |
sinon si java
>
>Sortir
Area of rectangle is: 50>
Nous pouvons voir dans le programme ci-dessus que chaque fois que le compilateur trouve AREA(l, b) dans le programme, il le remplace par l'instruction (l*b). Non seulement cela, mais les valeurs transmises au modèle de macro AREA(l, b) seront également remplacées dans l'instruction (l*b). Donc AREA(10, 5) sera égal à 10*5.
2. Inclusion de fichiers
Ce type de directive de préprocesseur indique au compilateur d'inclure un fichier dans le programme de code source. Le #include la directive du préprocesseur est utilisé pour inclure les fichiers d'en-tête dans le programme C.
Il existe deux types de fichiers qui peuvent être inclus par l'utilisateur dans le programme :
Fichiers d'en-tête standard
Les fichiers d'en-tête standard contiennent des définitions de fonctions prédéfinies telles que printf(), scanf(), etc. Ces fichiers doivent être inclus pour fonctionner avec ces fonctions. Différentes fonctions sont déclarées dans différents fichiers d'en-tête.
Par exemple, les fonctions d'E/S standard se trouvent dans le fichier « iostream » tandis que les fonctions qui effectuent des opérations sur les chaînes se trouvent dans le fichier « string ».
Syntaxe
#include < file_name>>
où nom de fichier est le nom du fichier d'en-tête à inclure. Le '' supports dites au compilateur de rechercher le fichier dans le répertoire s répertoire standard.
Fichiers d'en-tête définis par l'utilisateur
Lorsqu'un programme devient très volumineux, il est conseillé de le diviser en fichiers plus petits et de les inclure chaque fois que nécessaire. Ces types de fichiers sont des fichiers d'en-tête définis par l'utilisateur.
Syntaxe
#include ' filename '>
Le double citation ( ) dites au compilateur de rechercher le fichier d'en-tête dans le le répertoire du fichier source.
3. Compilation conditionnelle
Compilation conditionnelle dans les directives C est un type de directive qui permet de compiler une partie spécifique du programme ou d'ignorer la compilation d'une partie spécifique du programme en fonction de certaines conditions. Les directives de préprocesseur suivantes sont utilisées pour insérer du code conditionnel :
- #si Directive
- Directive #ifdef
- Directive #ifndef
- #else Directive
- Directive #elif
- Directive #endif
#fin si La directive est utilisée pour fermer les directives d'ouverture #if, #ifdef et #ifndef, ce qui signifie que le prétraitement de ces directives est terminé.
Syntaxe
#ifdef macro_name // Code to be executed if macro_name is defined # ifndef macro_name // Code to be executed if macro_name is not defined #if constant_expr // Code to be executed if constant_expression is true #elif another_constant_expr // Code to be excuted if another_constant_expression is true #else // Code to be excuted if none of the above conditions are true #endif>
Si la macro portant le nom ‘ nom_macro ' est défini, alors le bloc d'instructions s'exécutera normalement, mais s'il n'est pas défini, le compilateur ignorera simplement ce bloc d'instructions.
Exemple
L'exemple ci-dessous montre l'utilisation des directives de préprocesseur #include #if, #elif, #else et #endif.
C
//program to demonstrates the use of #if, #elif, #else,> // and #endif preprocessor directives.> #include> // defining PI> #define PI 3.14159> int> main()> {> > #ifdef PI> >printf>(>'PI is defined
'>);> > #elif defined(SQUARE)> >printf>(>'Square is defined
'>);> #else> >#error 'Neither PI nor SQUARE is defined'> #endif> > #ifndef SQUARE> >printf>(>'Square is not defined'>);> #else> >cout <<>'Square is defined'> << endl;> #endif> >return> 0;> }> |
>
>Sortir
PI is defined Square is not defined>
4. Autres directives
Outre les directives ci-dessus, il existe deux autres directives qui ne sont pas couramment utilisées. Ceux-ci sont:
- Directive #undef
- Directive #pragma
1. Directive #undef
La directive #undef est utilisée pour annuler la définition d'une macro existante. Cette directive fonctionne comme :
#undef LIMIT>
L’utilisation de cette instruction annulera la définition de la macro LIMIT existante. Après cette instruction, chaque instruction #ifdef LIMIT sera évaluée comme fausse.
Exemple
L'exemple ci-dessous démontre le fonctionnement de la directive #undef.
verilog toujours
C
#include> // defining MIN_VALUE> #define MIN_VALUE 10> int> main() {> >// Undefining and redefining MIN_VALUE> printf>(>'Min value is: %d
'>,MIN_VALUE);> > //undefining max value> #undef MIN_VALUE> > // again redefining MIN_VALUE> #define MIN_VALUE 20> >printf>(>'Min value after undef and again redefining it: %d
'>, MIN_VALUE);> >return> 0;> }> |
>
>Sortir
Min value is: 10 Min value after undef and again redefining it: 20>
2. Directive #pragma
Cette directive est une directive à usage spécial et est utilisée pour activer ou désactiver certaines fonctionnalités. Ces types de directives sont spécifiques au compilateur, c'est-à-dire qu'elles varient d'un compilateur à l'autre.
Syntaxe
#pragma directive>
Certaines des directives #pragma sont décrites ci-dessous :
- Démarrage #pragma : Ces directives nous aident à spécifier les fonctions qui doivent être exécutées avant le démarrage du programme (avant que le contrôle ne passe à main()).
- #pragma sortie : Ces directives nous aident à spécifier les fonctions qui doivent être exécutées juste avant la sortie du programme (juste avant le retour du contrôle de main()).
Le programme ci-dessous ne fonctionnera pas avec les compilateurs GCC.
Exemple
Le programme ci-dessous illustrer l'utilisation de #pragma exit et pragma startup
C
// C program to illustrate the #pragma exit and pragma> // startup> #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()
'>); }> void> func2() {>printf>(>'Inside func2()
'>); }> // driver code> int> main()> {> >void> func1();> >void> func2();> >printf>(>'Inside main()
'>);> >return> 0;> }> |
>
>
Production attendue
Inside func1() Inside main() Inside func2()>
Le code ci-dessus produira le résultat indiqué ci-dessous lorsqu'il sera exécuté sur les compilateurs GCC :
Inside main()c>
Cela se produit parce que GCC ne prend pas en charge le démarrage ou la sortie de #pragma. Cependant, vous pouvez utiliser le code ci-dessous pour le résultat attendu sur les compilateurs GCC.
dénomination des conventions Java
C
#include> void> func1();> void> func2();> void> __attribute__((constructor)) func1();> void> __attribute__((destructor)) func2();> void> func1()> {> >printf>(>'Inside func1()
'>);> }> void> func2()> {> >printf>(>'Inside func2()
'>);> }> int> main()> {> >printf>(>'Inside main()
'>);> >return> 0;> }> |
>
>Sortir
Inside func1() Inside main() Inside func2()>
Dans le programme ci-dessus, nous avons utilisé certains syntaxes spécifiques de sorte que l’une des fonctions s’exécute avant la fonction principale et l’autre s’exécute après la fonction principale.
#pragma avertit la directive
Cette directive est utilisée pour masquer le message d'avertissement qui s'affiche lors de la compilation. Nous pouvons masquer les avertissements comme indiqué ci-dessous :
- #pragma avertir -rvl : Cette directive masque les avertissements qui sont déclenchés lorsqu'une fonction censée renvoyer une valeur ne renvoie pas de valeur.
- #pragma avertir -par : Cette directive masque les avertissements qui sont déclenchés lorsqu'une fonction n'utilise pas les paramètres qui lui sont transmis.
- #pragma avertir -rch : Cette directive masque les avertissements qui sont déclenchés lorsqu'un code est inaccessible. Par exemple, tout code écrit après le retour l'instruction dans une fonction est inaccessible.
Si vous aimez techcodeview.com et souhaitez contribuer, vous pouvez également rédiger un article en utilisant . Consultez votre article apparaissant sur la page principale de techcodeview.com et aidez les autres Geeks. Veuillez écrire des commentaires si vous trouvez quelque chose d'incorrect ou si vous souhaitez partager plus d'informations sur le sujet abordé ci-dessus.