Comprendre le préprocesseur C (CPP) : Comment il simplifie la compilation

Le préprocesseur C n'est pas une partie du compilateur, mais une étape distincte du processus de compilation. En termes simples, le préprocesseur C est un outil de substitution de texte qui demande au compilateur d'effectuer le prétraitement nécessaire avant la compilation proprement dite. Nous l'appellerons CPP dans la suite.

Les directives du préprocesseur

Toutes les commandes du préprocesseur commencent par un symbole dièse (#). Il doit être le premier caractère non blanc et, pour la lisibilité, une directive de préprocesseur devrait commencer en première colonne. Voici les directives les plus importantes :

N°	Directive & Description
1	#define Définit une macro de préprocesseur (substitution de texte).
2	#include Insère le contenu d'un fichier d'en-tête.
3	#undef Supprime la définition d'une macro.
4	#ifdef Vrai si la macro est définie.
5	#ifndef Vrai si la macro n'est pas définie.
6	#if Teste une condition à la compilation.
7	#else Alternative pour #if.
8	#elif Combine #else et #if en une seule instruction.
9	#endif Termine un bloc conditionnel du préprocesseur.
10	#error Affiche un message d'erreur sur la sortie d'erreur standard.
11	#pragma Envoie des instructions spéciales au compilateur de manière standardisée.

Exemples de préprocesseur

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

#define MAX_ARRAY_LENGTH 20

Cette directive demande au CPP de remplacer toutes les occurrences de MAX_ARRAY_LENGTH par 20. Utilisez #define pour les constantes afin d'améliorer la lisibilité du code.

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

La première ligne demande au CPP de récupérer stdio.h dans les bibliothèques système et d'insérer son contenu dans le fichier source courant. La seconde ligne récupère mon_en_tete.h depuis le répertoire local.

#undef TAILLE_FICHIER
#define TAILLE_FICHIER 42

Cela demande au CPP de supprimer la définition existante de TAILLE_FICHIER puis de la redéfinir à 42.

#ifndef MESSAGE
#define MESSAGE "Vous souhaitez !"
#endif

Le CPP ne définit MESSAGE que si cette macro n'est pas déjà définie.

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

Le CPP traite les instructions comprises dans le bloc seulement si DEBUG est défini. C'est utile quand vous passez l'option -DDEBUG au compilateur GCC lors de la compilation. Cela définit DEBUG, vous permettant d'activer ou désactiver le débogage à la volée.

Macros prédéfinies

Le C ANSI définit un certain nombre de macros. Bien que chacune soit disponible pour la programmation, les macros prédéfinies ne doivent pas être modifiées directement.

N°	Macro & Description
1	__DATE__ La date courante sous forme de littéral caractère au format "MMM JJ AAAA".
2	__TIME__ L'heure courante sous forme de littéral caractère au format "HH:MM:SS".
3	__FILE__ Contient le nom du fichier courant sous forme de chaîne de caractères.
4	__LINE__ Contient le numéro de ligne courant sous forme de constante décimale.
5	__STDC__ Défini à 1 quand le compilateur est conforme à la norme ANSI.

Essayons l'exemple suivant :

Démonstration en direct

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

Lorsque le code ci-dessus dans un fichier test.c est compilé et exécuté, il produit le résultat suivant :

Fichier :test.c
Date :Juin 2 2012
Heure :03:36:24
Ligne :8
ANSI :1

Opérateurs du préprocesseur

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

L'opérateur de continuation de macro (\)

Une macro est normalement confinée à une seule ligne. L'opérateur de continuation de macro (\) permet de continuer une macro trop longue pour tenir sur une ligne. Par exemple :

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

L'opérateur de chaînage (#)

L'opérateur de chaînage ou dièse (#), lorsqu'il est utilisé dans une définition de macro, convertit un paramètre de macro en constante de chaîne. Cet opérateur ne peut être utilisé que dans une macro possédant une liste d'arguments spécifiée. Par exemple :

Démonstration en direct

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Carole et Debra : Nous vous aimons !

L'opérateur de concaténation de jetons (##)

L'opérateur de concaténation de jetons (##) dans une définition de macro combine deux arguments. Il permet de joindre deux jetons distincts dans la définition de macro en un seul jeton. Par exemple :

Démonstration en direct

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

jeton34 = 40

Cela se produit car cet exemple entraîne la sortie réelle suivante du préprocesseur :

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

Cet exemple montre la concaténation de jeton##n en jeton34 et utilise à la fois le chaînage et la concaténation de jetons.

L'opérateur defined()

L'opérateur defined du préprocesseur est utilisé dans les expressions constantes pour déterminer si un identifiant est défini via #define. Si l'identifiant spécifié est défini, la valeur est vraie (non-zéro). Sinon, elle est fausse (zéro). L'opérateur defined s'utilise comme suit :

Démonstration en direct

#include <stdio.h>
#if !defined (MESSAGE)
#define MESSAGE "Vous souhaitez !"
#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 le résultat suivant :

Voici le message : Vous souhaitez !

Macros paramétrées

L'une des fonctions puissantes du CPP est la capacité de simuler des fonctions à l'aide de macros paramétrées. Par exemple, pour calculer le carré d'un nombre :

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

On peut réécrire ce code avec une macro comme suit :

#define carre(x) ((x) * (x))

Les macros avec arguments doivent être définies avec la directive #define avant utilisation. La liste d'arguments est entre parenthèses et doit suivre immédiatement le nom de la macro. Les espaces ne sont pas autorisés entre le nom de la macro et la parenthèse ouvrante. Exemple :

Démonstration en direct

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

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant :

Max entre 20 et 10 est 20