Un forum pour les nouvelles technologies de l'information et de la communication.
 
AccueilCalendrierFAQRechercherMembresGroupesS'enregistrerConnexion


Partagez | 
 

 Le langage C Chapitre 11 : Les directives au préprocesseur

Aller en bas 
AuteurMessage
Administrateur
Admin
avatar

Messages : 118
Date d'inscription : 01/11/2012

MessageSujet: Le langage C Chapitre 11 : Les directives au préprocesseur   Dim 11 Nov - 13:52

Chapitre 5 Les
directives au préprocesseur




Le préprocesseur est un programme exécuté lors de la
première phase de la compilation. Il effectue des modifications textuelles sur
le fichier source à partir de directives. Les différentes directives
au préprocesseur, introduites par le caractère #,
ont pour but :



  • l'incorporation de fichiers
    source (#include),
  • la définition de constantes
    symboliques et de macros (#define),
  • la compilation
    conditionnelle (#if, #ifdef,...).


5.1 La directive #include



Elle permet d'incorporer dans le fichier source le texte
figurant dans un autre fichier. Ce dernier peut être un fichier en-tête de la
librairie standard (stdio.h, math.h,...) ou n'importe quel autre
fichier. La directive #include
possède deux syntaxes voisines :


#include

recherche le fichier mentionné dans un ou plusieurs
répertoires systèmes définis par l'implémentation (par exemple, /usr/include/) ;


#include "nom-de-fichier"

recherche le fichier dans le répertoire courant (celui où se
trouve le fichier source). On peut spécifier d'autres répertoires à l'aide de
l'option -I du compilateur.

La première syntaxe est généralement utilisée pour les fichiers en-tête de la
librairie standard, tandis que la seconde est plutôt destinée aux fichiers
créés par l'utilisateur.






5.2 La directive #define



La directive #define
permet de définir :



  • des constantes symboliques,
  • des macros avec paramètres.


5.2.1 Définition de constantes
symboliques




La directive


#define nom reste-de-la-ligne


demande au préprocesseur de substituer toute occurence de nom par la
chaîne de caractères reste-de-la-ligne
dans la suite du fichier source. Son utilité principale est de donner un nom
parlant à une constante, qui pourra être aisément modifiée. Par exemple :


#define NB_LIGNES 10#define NB_COLONNES 33#define TAILLE_MATRICE NB_LIGNES * NB_COLONNES

Il n'y a toutefois aucune contrainte sur la chaîne de
caractères reste-de-la-ligne.
On peut écrire


#define BEGIN {#define END }

5.2.2 Définition de macros



Une macro avec paramètres se définit de la manière
suivante :


#define nom(liste-de-paramètres) corps-de-la-macro


liste-de-paramètres
est une liste d'identificateurs séparés par des virgules. Par exemple, avec la
directive


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

le processeur remplacera dans la suite du code toutes les
occurences du type


MAX(x,y)

où x et y sont des symboles quelconques par


(x > y ? x : y)

Une macro a donc une syntaxe similaire à celle d'une
fonction, mais son emploi permet en général d'obtenir de meilleures
performances en temps d'exécution.

La distinction entre une définition de constante symbolique et celle d'une
macro avec paramètres se fait sur le caractère qui suit immédiatement le nom de
la macro : si ce caractère est une parenthèse ouvrante, c'est une macro
avec paramètres, sinon c'est une constante symbolique. Il ne faut donc jamais
mettre d'espace entre le nom de la macro et la parenthèse ouvrante. Ainsi, si l'on
écrit par erreur


#define CARRE (a) a * a

la chaîne de caractères CARRE(2)
sera remplacée par


(a) a * a (2)

Il faut toujours garder à l'esprit que le préprocesseur
n'effectue que des remplacements de chaînes de caractères. En particulier, il
est conseillé de toujours mettre entre parenthèses le corps de la macro et les
paramètres formels qui y sont utilisés. Par exemple, si l'on écrit sans
parenthèses :


#define CARRE(a) a * a

le préprocesseur remplacera CARRE(a
+ b) par a + b * a + b
et non par (a + b) * (a + b). De
même, !CARRE(x) sera remplacé
par ! x * x et non par !(x * x).

Enfin, il faut être attentif aux éventuels effets de bord que peut entraîner
l'usage de macros. Par exemple, CARRE(x++)
aura pour expansion (x++) * (x++).
L'opérateur d'incrémentation sera donc appliqué deux fois au lieu d'une.






5.3 La compilation conditionnelle



La compilation conditionnelle a pour but
d'incorporer ou d'exclure des parties du code source dans le texte qui sera
généré par le préprocesseur. Elle permet d'adapter le programme au matériel ou
à l'environnement sur lequel il s'exécute, ou d'introduire dans le programme
des instructions de débogage.

Les directives de compilation conditionnelle se répartissent en deux
catégories, suivant le type de condition invoquée :



  • la valeur d'une expression
  • l'existence ou
    l'inexistence de symboles.


5.3.1 Condition liée à la valeur d'une
expression




Sa syntaxe la plus générale est :


#if condition-1 partie-du-programme-1#elif condition-2 partie-du-programme-2 ...#elif condition-n partie-du-programme-n#else partie-du-programme-¥#endif

Le nombre de #elif
est quelconque et le #else est
facultatif. Chaque condition-i
doit être une expression constante.

Une seule partie-du-programme
sera compilée : celle qui correspond à la première condition-i non
nulle, ou bien la partie-du-programme-¥
si toutes les conditions sont nulles.

Par exemple, on peut écrire


#define PROCESSEUR ALPHA #if PROCESSEUR == ALPHA taille_long = 64;#elif PROCESSEUR == PC taille_long = 32;#endif

5.3.2 Condition liée à l'existence d'un
symbole




Sa syntaxe est


#ifdef symbole partie-du-programme-1#else condition-2 partie-du-programme-2#endif

Si symbole
est défini au moment où l'on rencontre la directive #ifdef, alors partie-duprogramme-1 sera compilée et partie-du-programme-2
sera ignorée. Dans le cas contraire, c'est partie-du-programme-2 qui sera compilée.
La directive #else est
évidemment facultative.

Da façon similaire, on peut tester la non-existence d'un symbole par :


#ifndef symbole partie-du-programme-1#else condition-2 partie-du-programme-2#endif

Ce type de directive est utile pour rajouter des
instructions destinées au débogage du programme :


#define DEBUG ....#ifdef DEBUG for (i = 0; i < N; i++) printf("%d\n",i);#endif /* DEBUG */

Il suffit alors de supprimer la directive #define DEBUG pour que les instructions
liées au débogage ne soient pas compilées. Cette dernière directive peut être
remplacée par l'option de compilation -Dsymbole, qui
permet de définir un symbole. On peut remplacer


#define DEBUG

en compilant le programme par


gcc -DDEBUG fichier.c


Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://jeveux.fra.co
 
Le langage C Chapitre 11 : Les directives au préprocesseur
Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» Langage Objet - static
» Questions - Futur de Panoramic Langage
» Toujours pour les férus d'électronique
» Pour les vrais débutants en programmation
» besion d'aide language html lecteur de musique !! (Résolu)

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
Forum Je veux :: Les logiciels PC: Windows, Linux, Jeux... :: Programmation, Web & Ftp-
Sauter vers:  

Vous êtes le visiteur N°

En s’abonnant aux flux RSS vous allez recevoir tous les articles de Forum " Je veux " dans votre lecteur de flux RSS quasiment instantanément après leurs publication.
L’intérêt est que vous n’êtes plus obliger de vous rendre sur le site pour voir s’il y a du nouveau.Pour nous suivre par RSS, cliquer sur le bouton RSS suivant:

Forum je veux


Forum Je Veux by A. Houssam


Annuaire gratuit Annuaire sites webMaroc index: Annuaire de sites marocains Annuaire sites webAvis consommateurs
Forum "Je veux" sur Facebook et Google
Chaque sujet enflame notre créativité