Préprocesseur C

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher

Le préprocesseur C ou cpp assure une phase préliminaire de la traduction (compilation) des programmes informatiques écrits dans les langages de programmation C et C++. Comme préprocesseur, il permet principalement l'inclusion d'un segment de code source disponible dans un autre fichier (fichiers d'en-tête ou header), la substitution de chaînes de caractères (macro définition), ainsi que la compilation conditionnelle.

Dans de nombreux cas, il s'agit d'un programme distinct du compilateur lui-même et appelé par celui-ci au début de la traduction. Le langage utilisé pour les directives du préprocesseur est indépendant de la syntaxe du langage C, de sorte que le préprocesseur C peut être utilisé isolément pour traiter d'autres types de fichiers sources.

Phases[modifier | modifier le code]

Les quatre premières (sur huit) phases de traduction pour la norme C sont les suivantes :

  1. Remplacement de tri-graphes : le préprocesseur remplace les séquences de tri-graphes par les caractères qu'ils représentent ;
  2. Raccordement de ligne : les lignes physiquement séparées mais qui sont connectées par des séquences de saut de ligne sont reliées pour former des lignes logiques ;
  3. Tokenisation : le préprocesseur découpe le code résultant en jetons (ou token) de pré-traitement et d'espaces insécables. Il retire les commentaires ;
  4. Expansion de macros et manipulation directive : les lignes contenant des directives de pré-traitement, dont l' inclusion de fichiers ou la compilation conditionnelle, sont exécutées. Le préprocesseur remplace chaque appel à une macro par sa définition. Dans la version 1999 de la norme C, il traite aussi les opérateurs _Pragma.

Types de directives[modifier | modifier le code]

Inclusion[modifier | modifier le code]

L'usage le plus fréquent du préprocesseur C est la directive:

 #include <…>

dont le rôle est de recopier le contenu d'un fichier dans le fichier courant. On l'emploie généralement pour inclure les en-têtes de bibliothèques, telles que les fonctions mathématiques (#include <math.h>) ou les fonctions d'entrée/sortie standard (#include <stdio.h>).

Dans l'exemple ci-dessous, la directive « #include <stdio.h> » est remplacée par le texte contenu dans le fichier stdio.h.

#include <stdio.h>
 
int main(void)
{
    printf("Bonjour le monde!\n");
    return 0;
}

Cette directive peut aussi être écrite en utilisant les guillemets doubles (" ") comme #include "stdio.h". Si le nom du fichier est enfermé à l'intérieur des chevrons ( < > ), le fichier est recherché dans les chemins connus d'un compilateur standard (aussi appelé include paths). Si le nom du fichier est encadré par des guillemets doubles, le répertoire courant est ajouté avant l'ensemble des chemins de recherche de fichiers; la recherche débute donc par le répertoire courant avant de se poursuivre dans ceux de chemins de recherche. Les compilateurs C et les environnements de développement permettent généralement au programmeur d'inclure les répertoires où les fichiers peuvent être trouvés.

Par convention, les fichiers à inclure ont une extension ".h" (ou .hpp en C++), et les fichiers ne devant être inclus ont une extension ".c" (ou ".cpp" en C++). Toutefois, il n'est pas nécessaire que cela soit observé. Occasionnellement, des fichiers avec d'autres extensions sont inclus: les fichiers avec une extension de .def peuvent désigner des fichiers destinés à être inclus plusieurs fois, à chaque fois élargissant le contenu à inclure, aussi #include "icon.xbm" fait référence à un fichier image XBM (qui est en même temps un fichier C).

La directive #include souvent est accompagnée de directives dites de #include guards ou de la directive #pragma pour éviter la double inclusion.

La compilation conditionnelle[modifier | modifier le code]

Les directives #if, #ifdef, #ifndef, #else, #elif and #endif peuvent être utilisées pour la compilation conditionnelle.

#if VERBOSE >= 2
  print("Hello world!");
#endif

La plupart des compilateurs pour Microsoft Windows définissent implicitement _WIN32. Cela permet au code, y compris les commandes de préprocesseur, de compiler uniquement lorsque l'on cible les systèmes d'exploitation Windows. Quelques compilateurs définissent WIN32 à la place. Pour les compilateurs qui ne définissent pas implicitement la macro _WIN32, il est possible de le spécifier sur la ligne de commande du compilateur, en utilisant -D_WIN32.

#ifdef __unix__ // __unix__ est souvent défini par les compilateurs pour des systèmes Unix 
# include <unistd.h>
#elif defined _WIN32 // _Win32 est souvent défini par les compilateurs pour des systèmes Windows 32 or 64 bit 
# include <windows.h>
#endif

Cet exemple de code teste si la macro __unix__ est définie. Si c'est le cas, le fichier <unistd.h> est inclus. Sinon, il teste si la macro _WIN32 est définie, au quel cas le fichier <windows.h> est inclus.

Il est possible d'utiliser des opérateurs avec la directive #if, comme :

#if !(defined __LP64__ || defined __LLP64__) || defined _WIN32 && !defined _WIN64
	// compilation pour un système 32-bit
#else
	// compilation pour un système 64-bit
#endif

La majorité des langages de programmation modernes n'utilisent pas ces fonctionnalités et dépendent plutôt d'une utilisation des habituels opérateurs if…then…else…, laissant au compilateur la tâche de supprimer le code inutile.

Définition de macro et expansion[modifier | modifier le code]

Le mécanisme des macros est fréquemment utilisé en C pour définir de petits extraits de code qui seront réutilisés à divers endroits du programme. Durant l'exécution du préprocesseur, chaque appel de la macro est remplacé, dans le corps du fichier, par la définition de cette macro.

Les syntaxes générales pour déclarer une macro de remplacement de type objet et fonction, respectivement, sont :

#define <identifiant> <contenu de remplacement> // type objet
#define <identifiant>(<liste des paramètres>) <contenu de remplacement> // type fonction avec paramètres

Les macros de type fonction ne doivent pas contenir d'espace entre l'identifiant et la parenthèse ouvrante.

Un exemple de macro de type objet est :

#define PI 3.14159

qui définit une macro PI (identifiant) qui prendra la valeur 3.14159 (contenu de remplacement). Cette macro peut être appelée comme n'importe quelle fonction C. Ainsi, après passage du préprocesseur, double z =PI; sera remplacé par double z = 3.14159;

Un exemple de macro de type fonction :

 #define MAX(a,b) a>b?a:b

définit la macro MAX (identifiant), prenant 2 paramètres (a et b) et calculant a>b?a:b (contenu de remplacement). Cette macro peut être appelée comme n'importe quelle fonction C. Ainsi, après passage du préprocesseur, z = MAX(x,y); sera remplacé par z = x>y?x:y;

Cet usage des macros est fondamental en C, notamment pour définir des structures de données sûres ou en tant qu'outil de débogage, cependant il peut ralentir la compilation et parfois l'exécution, et présente de nombreux pièges. Ainsi, si f et g sont deux fonctions, z = MAX(f(), g()); sera remplacée par z = (f() > g())?f():g();. Cette commande nécessite deux fois l'évaluation d'une des deux fonctions, ce qui ralentit le code.

À noter aussi, qu'il est possible d'annuler la définition d'une macro avec la directive "#undef" :

#undef <identifier>

Concatenation de tokens[modifier | modifier le code]

L’opérateur ## élimine tous les espaces (ou whitespace) autour de lui et concatène (assemble) deux tokens (ou jetons) en un. Cela sert à créer de nouveaux tokens et ne peut être utilisé que dans des macros, comme :

#define ma_macro(x) x ## _suffixe

remplacera

ma_macro(identifiant);

par

identifiant_suffixe;

Erreurs de compilation définies par l'utilisateur[modifier | modifier le code]

La directive #error ajoute un message au flux des messages d'erreur.

#error "message d'erreur"

Il est ainsi possible d'utiliser ces directives, par exemple pour créer une erreur de traduction :

#if RUBY_VERSION == 190
#error 1.9.0 not supported
#endif

Implementations[modifier | modifier le code]

Caracteristiques des préprocesseurs specifiques à un compilateur[modifier | modifier le code]

La directive #pragma[modifier | modifier le code]

La directive #pragma est une directive spécifique à un compilateur. Cette directive est souvent utilisée pour permettre la suppression de certains messages d'erreur ou pour gerer la pile ou le tas de deboguage.

La version 1999 de la norme C (C99) introduit une série de directives #pragma, telles que #pragma STDC pour contrôler la précision numérique.

Messages d'alerte[modifier | modifier le code]

De nombreuses implémentations (dont les compilateurs C pour GNU, intel, Microsoft et IBM) fournissent une directive non standard pour afficher des messages d'alerte dans la sortie sans toutefois arrêter la compilation. Un usage fréquent de ce type de directives est de prévenir qu'une partie du code est dépréciée:

  • Pour GNU, Intel et IBM:
#warning "Ne pas utiliser SOPA ou PIPA, qui sont dépréciées. Utilisez CC à la place."
  • Microsoft:
#pragma message("Ne pas utiliser SOPA ou PIPA, qui sont depreciées. Utilisez CC a la place.")

Autres directives spécifiques[modifier | modifier le code]

  • Le préprocesseur de GCC autorise la directive #include_next. Cette directive indique au préprocesseur de continuer à chercher le nom de fichier spécifié et de l'inclure après le répertoire courant. La syntaxe est similaire à #include.
  • Les préprocesseurs de Objective-C comprennent la directive #import, qui est similaire à #include mais n'inclut le fichier qu'une seule fois.

Bibliographie[modifier | modifier le code]

Glossaire[modifier | modifier le code]

Le terme directive renvoie aux lignes du code source devant être traitées par le préprocesseur (p. ex. #define ou #include). Par extension, il sert à désigner l'instruction ou macro-définition destinée au préprocesseur.

Outils[modifier | modifier le code]

L'outil GNU Cppi vise à la bonne indentation des directives du préprocesseur pour refléter leur imbrication, et veille à ce qu'il y ait exactement un espace entre chaque directive #if, #elif, #define et le jeton suivant, pour in fine écrire le résultat en sortie. Le nombre d'espaces entre le caractère `#' et la directive suivante doit correspondre au niveau d'imbrication de cette directive (voir aussi le livre cppi sur Wikibooks). C'est un paquet GNU maintenu par Jim Meyering et distribué selon les termes de la licence publique générale GNU[1].

Notes et références[modifier | modifier le code]

  1. Jim Meyering (16 mars 2013), « cppi-1.18 released », info-gnu.