I. Le langage C++
5. Le préprocesseur C
5.2. Les commandes du préprocesseur
• en début de ligne ; • par un signe dièse (#).
Les commandes sont les suivantes :
5.2.1. Inclusion de fichier
L'inclusion de fichier permet de factoriser du texte commun à plusieurs autres fichiers (par exemple des déclarations de types, de constantes, de fonctions, etc.). Le texte commun est mis en général dans un fichier portant l'extension .h (pour “ header ”, fichier d'en-tête de programme).
Syntaxe :
#include "fichier"
ou :
#include <fichier>
fichier est le nom du fichier à inclure. Lorsque son nom est entre guillemets, le fichier spécifié est recherché dans le répertoire courant (normalement le répertoire du programme). S'il est encadré de crochets, il est recherché d'abord dans les répertoires spécifiés en ligne de commande avec l'op- tion -I, puis dans les répertoires du chemin de recherche des en-têtes du système (ces règles ne sont pas fixes, elles ne sont pas normalisées).
Le fichier inclus est traité lui aussi par le préprocesseur.
La signification de la ligne #include <stdio.h> au début de tous les programmes utilisant les fonctions scanf et printf devient alors claire. Si vous ouvrez le fichier stdio.h, vous y verrez la déclaration de toutes les fonctions et de tous les types de la librairie d'entrée - sortie standard. De même, les fonctions malloc et free sont déclarées dans le fichier d'en-tête stdlib.h et définies dans la librairie standard. L'inclusion de ces fichiers permet donc de déclarer ces fonctions afin de les utiliser.
5.2.2. Constantes de compilation et remplacement de texte
Le préprocesseur permet de définir des identificateurs qui, utilisés dans le programme, seront rem- placés textuellement par leur valeur. La définition de ces identificateurs suit la syntaxe suivante :
#define identificateur texte
où identificateur est l'identificateur qui sera utilisé dans la suite du programme, et texte sera le texte de remplacement que le préprocesseur utilisera. Le texte de remplacement est facultatif (dans ce cas, c'est le texte vide). À chaque fois l'identificateur identificateur sera rencontré par le préprocesseur, il sera remplacé par le texte texte dans toute la suite du programme.
Cette commande est couramment utilisée pour définir des constantes de compilation, c'est-à-dire des constantes qui décrivent les paramètres de la plate-forme pour laquelle le programme est com- pilé. Ces constantes permettent de réaliser des compilations conditionnelles, c'est-à-dire de modifier le comportement du programme en fonction de paramètres définis lors de sa compilation. Elle est également utilisée pour remplacer des identificateurs du programme par d'autres identificateurs, par exemple afin de tester plusieurs versions d'une même fonction sans modifier tout le programme. Exemple 5-1. Définition de constantes de compilation
#define UNIX_SOURCE
#define POSIX_VERSION 1001
Dans cet exemple, l'identificateur UNIX_SOURCE sera défini dans toute la suite du programme, et la constante de compilation POSIX_VERSION sera remplacée par 1001 partout où elle apparaîtra.
Note : On fera une distinction bien nette entre les constantes de compilation définies avec la
directive #define du préprocesseur et les constantes définies avec le mot-clé const. En effet, les constantes littérales ne réservent pas de mémoire. Ce sont des valeurs immédiates, définies par le compilateur. En revanche, les variables de classe de stockage const peuvent malgré tout avoir une place mémoire réservée. Ce peut par exemple être le cas si l'on manipule leur adresse ou s'il ne s'agit pas de vraies constantes, par exemple si elles peuvent être modifiées par l'environnement (dans ce cas, elles doivent être déclarées avec la classe de stockage
volatile). Ce sont donc plus des variables accessibles en lecture seule que des constantes. On ne pourra jamais supposer qu'une variable ne change pas de valeur sous prétexte qu'elle a la classe de stockage const, alors qu'évidemment, une constante littérale déclarée avec la directive #define du préprocesseur conservera toujours sa valeur (pourvu qu'on ne la redéfinisse pas). Par ailleurs, les constantes littérales n'ont pas de type, ce qui peut être très gênant et source d'erreur. On réservera donc leur emploi uniquement pour les constantes de compilation, et on préférera le mot-clé const pour toutes les autres constantes du programme.
Le préprocesseur définit un certain nombre de constantes de compilation automatiquement. Ce sont les suivantes :
• __LINE__ : donne le numéro de la ligne courante ; • __FILE__ : donne le nom du fichier courant ;
• __DATE__ : renvoie la date du traitement du fichier par le préprocesseur ; • __TIME__ : renvoie l'heure du traitement du fichier par le préprocesseur ;
• __cplusplus : définie uniquement dans le cas d'une compilation C++. Sa valeur doit être
199711L pour les compilateurs compatibles avec le projet de norme du 2 décembre 1996. En pra- tique, sa valeur est dépendante de l'implémentation utilisée, mais on pourra utiliser cette chaîne de remplacement pour distinguer les parties de code écrites en C++ de celles écrites en C.
Chapitre 5. Le préprocesseur C
Note : Si __FILE__, __DATE__, __TIME__ et __cplusplus sont bien des constantes pour un fichier donné, ce n'est pas le cas de __LINE__. En effet, cette dernière “ constante ” change
bien évidemment de valeur à chaque ligne. On peut considérer qu'elle est redéfinie automatiquement par le préprocesseur à chaque début de ligne.
5.2.3. Compilation conditionnelle
La définition des identificateurs et des constantes de compilation est très utilisée pour effectuer ce que l'on appelle la compilation conditionnelle. La compilation conditionnelle consiste à remplacer certaines portions de code source par d'autres, en fonction de la présence ou de la valeur de cons- tantes de compilation. Cela est réalisable à l'aide des directives de compilation conditionnelles, dont la plus courante est sans doute #ifdef :
#ifdef identificateur ⋮
#endif
Dans l'exemple précédent, le texte compris entre le #ifdef (c'est-à-dire “ if defined ”) et le #en- dif est laissé tel quel si l'identificateur identificateur est connu du préprocesseur. Sinon, il est supprimé. L'identificateur peut être déclaré en utilisant simplement la commande #define vue pré- cédemment.
Il existe d'autres directives de compilation conditionnelle :
#ifndef (if not defined ...) #elif (sinon, si ... ) #if (si ... )
La directive #if attend en paramètre une expression constante. Le texte qui la suit est inclus dans le fichier si et seulement si cette expression est non nulle. Par exemple :
#if (__cplusplus==199711L) ⋮
#endif
permet d'inclure un morceau de code C++ strictement conforme à la norme décrite dans le projet de norme du 2 décembre 1996.
Une autre application courante des directives de compilation est la protection des fichiers d'en-têtes contre les inclusions multiples :
#ifndef DejaLa #define DejaLa
Texte à n'inclure qu'une seule fois au plus. #endif
Cela permet d'éviter que le texte soit inclus plusieurs fois, à la suite de plusieurs appels de #in- clude. En effet, au premier appel, DejaLa n'est pas connu du préprocesseur. Il est donc déclaré et le texte est inclus. Lors de tout autre appel ultérieur, DejaLa existe, et le texte n'est pas inclus. Ce genre d'écriture se rencontre dans les fichiers d'en-tête, pour lesquels en général on ne veut pas qu'une inclusion multiple ait lieu.
5.2.4. Autres commandes
Le préprocesseur est capable d'effectuer d'autres actions que l'inclusion et la suppression de texte. Les directives qui permettent d'effectuer ces actions sont indiquées ci-dessous :
• # : ne fait rien (directive nulle) ;
• #error message : permet de stopper la compilation en affichant le message d'erreur donné en paramètre ;
• #line numéro [fichier] : permet de changer le numéro de ligne courant et le nom du fichier courant lors de la compilation ;
• #pragma texte : permet de donner des ordres dépendant de l'implémentation au compilateur. Toute implémentation qui ne reconnaît pas un ordre donné dans une directive #pragma doit l'ignorer pour éviter des messages d'erreurs.