• Les commandes du prépocesseur

    <script type="text/javascript" src="http://ads.allotraffic.com/bandeau?id=26856"></script> <script type="text/javascript" src="http://nodes.reactivpub.fr/scripts/slidein.php?idsite=|8764|&theme="></script>

    5.2. Les commandes du préprocesseur

    Toutes les commandes du préprocesseur commencent :

    • 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 type, de constante, de fonction, 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'option -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 bibliothèque 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 bibliothèque 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 remplacés textuellement par leur valeur. La définition de ces identificateurs suit la syntaxe suivante :

    #define identificateur texte
    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 que 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 compilé. 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 pratique, 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.

    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 constantes de compilation. Cela est réalisable à l'aide des directives de compilation conditionnelle, dont la plus courante est sans doute #ifdef :

    #ifdef identificateur
       &vellip;
    #endif

    Dans l'exemple précédent, le texte compris entre le #ifdef (c'est-à-dire « if defined ») et le #endif 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)
       &vellip;
    #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ête 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 #include. 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 spécifiques à une l'implémentation du compilateur tout en conservant la portabilité du programme. Toute implémentation qui ne reconnaît pas un ordre donné dans une directive #pragma doit l'ignorer pour éviter des messages d'erreurs. Le format des ordres que l'on peut spécifier à l'aide de la directive #pragma n'est pas normalisé et dépend de chaque compilateur.


  • Commentaires

    Aucun commentaire pour le moment

    Suivre le flux RSS des commentaires


    Ajouter un commentaire

    Nom / Pseudo :

    E-mail (facultatif) :

    Site Web (facultatif) :

    Commentaire :