Préprocesseur en C

Dans ce tutoriel, nous vous présenterons le préprocesseur C et apprendrez à utiliser #include, #define et la compilation conditionnelle avec des exemples. Le préprocesseur C est un préprocesseur de macro (qui vous permet de définir des macros) qui peut être transformé avant la compilation du programme. Ces transformations peuvent inclure les fichiers d'en-tête, l'extension des macros, etc. Toutes les instructions de prétraitement commencent par le symbole #.

Exemple de préprocesseur

Analysez les exemples suivants pour comprendre les différentes instructions.

#define MAX_ARRAY_LENGTH　20

Cette instruction indique à CPP de remplacer tous les MAX_ARRAY_LENGTH par 20. Utiliser #define définir des constantes pour améliorer la lisibilité.

#include <stdio.h>
#include "myheader.h"

ces instructions indiquent à CPP de récupérerbibliothèque systèmeObtenir stdio.h et ajouter le texte au fichier source actuel. La ligne suivante indique à CPP de récupérer myheader.het ajoute du contenu au fichier source actuel.

#undef FILE_SIZE
#define FILE_SIZE　42

Cette instruction informe le CPP de la suppression de FILE_SIZE déjà défini et de sa définition en tant que 42.

#ifndef MESSAGE
　　　#define MESSAGE "You wish!"
#endif

Cette instruction informe le CPP de la définition de MESSAGE uniquement si MESSAGE n'est pas défini.

#ifdef DEBUG
　　　/*　Vos instructions de débogage ici　*/
#endif

Cette instruction informe le CPP de l'exécution des instructions de traitement si DEBUG est défini. Lors de la compilation, si vous avez transmis -DDEBUG Les quantités de commutation, cette instruction est très utile. Elle définit DEBUG, que vous pouvez activer ou désactiver à tout moment pendant la compilation.

Macros prédéfinies

ANSI C définit de nombreuses macros. Vous pouvez utiliser ces macros en programmation, mais vous ne pouvez pas modifier directement ces macros prédéfinies.

Essayons l'exemple suivant :

#include <stdio.h>
main()
{
　　　printf("File :%s\n", __FILE__);
　　　printf("Date :%s\n", __DATE__);
　　　printf("Time :%s\n", __TIME__);
　　　printf("Ligne :%d\n", __LINE__);
　　　printf("ANSI :%d\n", __STDC__);
}

Lorsque le code suivant (dans le fichier test.c Lorsqu'il est compilé et exécuté, il produit les résultats suivants :

File :test.c
Date :Jun　2　2012
Time :03:36:24
Ligne :8
ANSI :1

Opérateurs de préprocesseur

Le préprocesseur C fournit les opérateurs suivants pour vous aider à créer des macros :

Opérateur de prolongement de macro (\)

Une macro est généralement écrite sur une ligne. Mais si la macro est trop longue pour être contenue sur une seule ligne, utilisez l'opérateur de prolongement de macro (\). Par exemple :

#define message_for(a, b) \\"}}
　　　　printf(#a " et " #b ": Nous vous aimons !\n")

Opérateur de quantification de chaîne (#)

Dans les définitions de宏，quand il est nécessaire de convertir un paramètre de macro en une constante de chaîne de caractères, utilisez l'opérateur de quantification de chaîne de caractères (#). Cet opérateur utilisé dans la macro a un paramètre spécifique ou une liste de paramètres. Par exemple :

#include <stdio.h>
#define message_for(a, b) \\"}}
　　　　printf(#a " et " #b ": Nous vous aimons !\n")
int main(void)
{
　　　message_for(Carole, Debra);
　　　return 0;
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Carole et Debra : Nous vous aimons !

Opérateur de collage de marque (##)

L'opérateur de collage de marque (##) dans la définition de macro combine deux paramètres. Il permet de fusionner deux marqueurs indépendants en un seul marqueur dans une définition de macro. Par exemple :

#include <stdio.h>
#define tokenpaster(n) printf("token" #n " = %d", token##n)
int main(void)
{
　　　int token34　=　40;
　　　
　　　tokenpaster(34);
　　　return 0;
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

token34　=　40

Voici comment cela se produit, car cet exemple génère le sortie réelle suivante du compilateur :

printf("token"34　= %d", token34);

Cet exemple montre que token##n se connecte à token34 dans lequel, nous avons utiliséOpérateur de quantification de chaîne (#)etOpérateur de collage de marque (##).

Opérateur defined()

Préprocesseur defined Les opérateurs sont utilisés dans des expressions constantes pour déterminer si un identificateur a été défini avec #define. Si l'identificateur spécifié est défini, la valeur est vraie (non nulle). Si l'identificateur spécifié n'est pas défini, la valeur est fausse (nulle). Le siguiente exemple montre l'utilisation de l'opérateur defined() :

#include <stdio.h>
#if !defined(MESSAGE)
　　　#define MESSAGE "You wish!"
#endif
int main(void)
{
　　　printf("Voici le message : %s\n", MESSAGE);　　
　　　return 0;
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

Voici le message : 'You wish!'

Macro paramétrée

Une fonctionnalité puissante de CPP est la capacité d'utiliser des macros paramétrées pour simuler des fonctions. Par exemple, le code suivant calcule le carré d'un nombre :

int square(int x) {
　　　return x　*　x;
}

Nous pouvons réécrire le code ci-dessus à l'aide de macros, comme suit :

#define square(x) ((x)　*　(x))

Avant d'utiliser une macro avec des paramètres, il est nécessaire d'utiliser #define Définition d'instruction. La liste des paramètres est encadrée par des parenthèses et doit suivre immédiatement le nom de la macro. Il n'est pas autorisé d'insérer des espaces entre le nom de la macro et l'ouvrante. Par exemple :

#include <stdio.h>
#define MAX(x,y) ((x) > (y) ? (x) : (y))
int main(void)
{
　　　printf("10jusqu'à2La valeur maximale entre 0 et %d\n", MAX(10,　20));　　
　　　return 0;
}

Lorsque le code suivant est compilé et exécuté, il produit les résultats suivants :

10jusqu'à2La valeur maximale entre 0 et　20