C Préprocesseur

Préprocesseur C (CPP)est une phase indépendante du processus de compilation, dansAvant la compilation réellele traitement textuel du code source. Les principales fonctionnalités incluent :

  • Expansion des macros
  • Inclusion de fichiers
  • Compilation conditionnelle
  • Traitement des directives spéciales

Préprocesseur CIl n'est pas un composant du compilateur, mais il s'agit d'une étape distincte du processus de compilation.

En bref, le préprocesseur C n'est rien de plus qu'un outil de remplacement de texte, qui indique au compilateur d'effectuer le prétraitement requis avant la compilation réelle.

Nous abrégerons le préprocesseur C en CPP.

Toutes les commandes du préprocesseur commencent par un signe dièse#Le début. Il doit être le premier caractère autre qu'un espace. Pour des raisons de lisibilité, les directives du préprocesseur doivent commencer à la première colonne.

Toutes les directives importantes du préprocesseur sont listées ci-dessous :

Directive Description Exemples d’utilisation
#define Définir des macros (constantes symboliques ou macros de type fonction) #define PI 3.14159
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#include Inclure les fichiers d'en-tête #include <stdio.h>
#include "myheader.h"
#undef Annuler la définition d'une macro #undef PI
#ifdef Compiler le code suivant si la macro est définie #ifdef DEBUG
printf("Debug info\n");
#endif
#ifndef Si la macro n'est pas définie, compiler le code suivant (couramment utilisé pour la protection des fichiers d'en-tête) #ifndef HEADER_H
#define HEADER_H
/* content */
#endif
#if Compilation conditionnelle (peut être utilisée avec l'opérateur defined) #if VERSION > 2
/* new version code */
#endif
#else #if/#ifdef/#ifndefla branche alternative #ifdef WIN32
/* Windows代码 */
#else
/* other systems */
#endif
#elif Semblable à else if #if defined(UNIX)
/* Unix代码 */
#elif defined(WIN32)
/* Windows代码 */
#endif
#endif Terminer le bloc de compilation conditionnelle Comme le montre l'exemple ci-dessus
#error Générer une erreur de compilation et afficher un message #if !defined(C99)
#error "需要C99标准"
#endif
#pragma Directives spécifiques au compilateur (non standard, varient d'un compilateur à l'autre) #pragma once
#pragma pack(1)

Exemples de préprocesseur

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

#define MAX_ARRAY_LENGTH 20

Cette directive indique à CPP de définir MAX_ARRAY_LENGTH comme 20. Utilisez#definepour définir des constantes afin d'améliorer la lisibilité.

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

Ces directives indiquent à CPP de récupérer stdio.h depuis labibliothèque système, et d'ajouter le texte au fichier source actuel. La ligne suivante indique à CPP de le récupérer depuis le répertoire localmyheader.h, et d'ajouter le contenu au fichier source actuel.

#undef  FILE_SIZE
#define FILE_SIZE 42

Cette directive indique à CPP d'annuler la définition de FILE_SIZE et de la définir comme 42.

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

Cette directive indique à CPP de définir MESSAGE uniquement lorsque MESSAGE n'est pas défini.

#ifdef DEBUG
   /* Your debugging statements here */
#endif

Cette directive indique à CPP d'exécuter les instructions de traitement si DEBUG est défini. Au moment de la compilation, si vous passez l'option au compilateur gcc,-DDEBUGcette directive est très utile. Elle définit DEBUG, et vous pouvez activer ou désactiver le débogage à tout moment pendant la compilation.

Exemple

#include <stdio.h>

// Définir une macro constante
#define PI 3.1415926
#define GREETING "Hello, World!"

// Définir une macro de type fonction (notez l'utilisation des parenthèses)
#define SQUARE(x) ((x) * (x))
#define MAX(a, b) ((a) > (b) ? (a) : (b))

// Exemple de compilation conditionnelle
#define DEBUG 1

int main() {
    // Utilisation de macros constantes
    printf("La valeur de PI : %f\n", PI);
    printf("%s\n", GREETING);
   
    // Utilisation de macros de type fonction
    int x = 5;
    printf("%d au carré est : %d\n", x, SQUARE(x));
    printf("Le plus grand de 3 et 5 est : %d\n", MAX(3, 5));
   
    // Exemple de compilation conditionnelle
    #ifdef DEBUG
    printf("[Infos de débogage] Le programme a atteint la fonction main\n");
    #endif
   
    // Vérification de la version du compilateur
    #if __STDC_VERSION__ >= 201112L
    printf("Utilisation de la norme C11\n");
    #elif __STDC_VERSION__ >= 199901L
    printf("Utilisation de la norme C99\n");
    #else
    printf("Utilisation de la norme C89/C90\n");
    #endif
   
    // Exemple de directive d'erreur (le fait de décommenter provoquera une erreur de compilation)
    // #error "This is a manually triggered error"
   
    return 0;
}

Recommandations de bonnes pratiques

  1. Nommage des macros:

    • Utiliser des lettres majuscules et des traits de soulignement pour nommer les macros
    • Exemple :#define MAX_SIZE 100
  2. Remarques sur les macros de type fonction:

    • Chaque paramètre et l'expression entière doivent être mis entre parenthèses.
    • Éviter d'utiliser des arguments avec des effets de bord (par ex.SQUARE(x++))
  3. Protection des fichiers d'en-tête:

    #ifndef MY_HEADER_H
    #define MY_HEADER_H
    /* 头文件内容 */
    #endif
  4. Débogage par compilation conditionnelle:

    #ifdef DEBUG
    #define DEBUG_PRINT(fmt, ...) printf(fmt, ##__VA_ARGS__)
    #else
    #define DEBUG_PRINT(fmt, ...)
    #endif
    
  5. Développement multiplateforme:

    #if defined(_WIN32)
    // Windows特定代码
    #elif defined(__linux__)
    // Linux特定代码
    #elif defined(__APPLE__)
    // macOS特定代码
    #endif
    

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.

MacroDescription
__DATE__Date actuelle, une constante caractère au format "MMM DD YYYY".
__TIME__Heure actuelle, une constante caractère au format "HH:MM:SS".
__FILE__Ceci contient le nom du fichier actuel, une constante chaîne.
__LINE__Ceci contient le numéro de ligne actuel, une constante décimale.
__STDC__Défini à 1 lorsque le compilateur compile conformément à la norme ANSI.

Essayons l'exemple suivant :

Exemple

#include <stdio.h> /** Programme de démonstration des macros prédéfinies * Démontre les macros prédéfinies courantes de la norme ANSI C et leurs utilisations*/ int main() { // Affiche le nom du fichier source actuel (constante de chaîne) printf("Fichier actuel : %s\n", __FILE__); // Affiche la date de compilation (format "MMM DD YYYY") printf("Date de compilation : %s\n", __DATE__); // Affiche l'heure de compilation (format "HH:MM:SS") printf("Heure de compilation : %s\n", __TIME__); // Affiche le numéro de ligne actuel (entier décimal) printf("Numéro de ligne actuel : %d\n", __LINE__); // Vérifie s'il est conforme à la norme ANSI/ISO (1 signifie conforme) printf("Norme ANSI : %d\n", __STDC__); // Exemple pratique : sortie d'informations de débogage printf("\n[Info de débogage] %s (ligne %d) compilé le %s %s\n", __FILE__, __LINE__, __DATE__, __TIME__); return 0; }

Lorsque le code ci-dessus (dans le fichiertest.c) est compilé et exécuté, il produit les résultats suivants :

当前文件: predef_macros.c
编译日期: Jul 5 2023
编译时间: 14:30:45
当前行号: 13
ANSI标准: 1

[调试信息] predef_macros.c (第16行) 编译于 Jul 5 2023 14:30:45

Opérateurs de préprocesseur

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

Opérateur de continuation de macro (\\)

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

#define  message_for(a, b)  \
    printf(#a " and " #b ": We love you!\n")

Opérateur de mise en chaîne (#)

Dans une définition de macro, lorsque vous devez convertir un paramètre de macro en une constante de chaîne, utilisez l'opérateur de mise en chaîne (#). L'opérateur utilisé dans une macro a un paramètre spécifique ou une liste de paramètres. Par exemple :

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 ci-dessus est compilé et exécuté, il produit les résultats suivants :

Carole and Debra: We love you!

Opérateur de collage de jetons (##)

L'opérateur de collage de jetons (##) dans une définition de macro fusionne deux paramètres. Il permet à deux jetons séparés dans la définition de macro d'être fusionnés en un seul jeton. Par exemple :

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 ci-dessus est compilé et exécuté, il produit les résultats suivants :

token34 = 40

Voici comment cela se produit, car cet exemple produira la sortie réelle suivante du compilateur :

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

Cet exemple montre que token##n se concatène en token34 ; ici, nous avons utiliséopérateur de stringification (#)etopérateur de collage de jetons (##)。

L'opérateur defined()

PréprocesseurdefinedL'opérateur est utilisé dans les expressions constantes pour déterminer si un identificateur a déjà é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 (zéro). L'exemple suivant montre l'utilisation de l'opérateur defined() :

Exemple

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

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

Here is the message: You wish!

Macros paramétrées

Une fonctionnalité puissante du CPP est la possibilité 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 d'une macro comme suit :

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

Avant d'utiliser une macro avec des paramètres, vous devez utiliser la directive#definepour la définir. La liste des paramètres est placée entre parenthèses et doit suivre immédiatement le nom de la macro. Aucun espace blanc n'est autorisé entre le nom de la macro et la parenthèse ouvrante. Par exemple :

Exemple

#include <stdio.h> #define MAX(x,y) ((x) > (y) ? (x) : (y)) int main(void) { printf("Le maximum entre 20 et 10 est %d\n", MAX(10, 20)); return 0; }

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

Max between 20 and 10 is 20
autres extensions