Programmation

Séquence 2 : Objectif 27 : Manipuler le préprocesseur et compiler un programme contenu dans plusieurs fichiers

Programmation
Dr Guy MBATCHOU
Séquence 2 : Objectif 27 : Manipuler le préprocesseur et compiler un programme
contenu dans plusieurs fichiers

Dr Guy MBATCHOU 1
Programmation
Séquence 2 : Objectif 27 : Manipuler le préprocesseur et compiler un programme contenu dans plusieurs fichiers

Objectif 27 : Manipuler le préprocesseur et compiler un programme contenu dans

plusieurs fichiers

Jusqu’à présent, nous avons toujours écrit tout notre programme (main + autres fonctions) dans un seul fichier
d’extension « .c ». Or il arrive que le programme contienne un nombre grand de fonctions ; ce qui rend le fichier long
et difficile à lire. Précédemment, nous avons vu la modularité du programme en plusieurs fonctions. A présent, nous
allons découper notre programme en plusieurs fichiers ce qui facilitera son organisation, sa lecture, sa compréhension,
la réutilisation de certaines fonctions dans d’autres projets et sa maintenance.

Fichier source
Un programme écrit en plusieurs fichiers contient obligatoirement plusieurs fichiers sources. Un fichier source est un
fichier d’extension « .c » contenant le code source (définition) des fonctions. Nous avons vu précédemment pour éviter
de respecter un quelconque ordre lors de la définition des fonctions, on peut insérer au début du fichier source les
déclarations des différentes fonctions. En compilation séparée (compilation à partir de plusieurs fichiers sources), ces
déclarations peuvent faire l’objet d’un fichier qui est appelé fichier d’entête.

Fichier d’entête
Un fichier d’entête est un fichier d’extension « .h » contenant les :

 déclarations de fonctions,

 définitions des types de données (types utilisateur),

 définitions de macros,

 etc.
communes à plusieurs fichiers sources.

Un fichier d’entête ne doit pas forcément contenir tous les éléments cités.

Ces fichiers doivent être inclus dans les fichiers sources nécessaires avec l’instruction suivante :

include "fichier_entete.h"
L’inclusion du fichier d’entête se fait avec les guillemets (") contrairement aux fichiers des bibliothèques qui se fait avec
des crochets (< et >).

Les directives du préprocesseur

Vu qu’un fichier d’entête est conçu pour être inclus dans plusieurs fichiers sources pouvant appartenir au même
projet, il peut arriver qu’il y ait des inclusions multiples qui alourdissent inutilement le programme. Pour éviter cela, il
existe des directives du préprocesseur qui vérifiera si les fichiers d’entête non pas été inclus avant de les inclure.

Les directives du préprocesseur sont des instructions commençant par le symbole « # » qui sont réalisées avant la
compilation des fichiers sources.

Les inclusions de fichiers

La directive include permet l’inclusion d’un fichier d’entête (#include "Entete.h" par exemple) ou d’une bibliothèque
de fonctions (#include <float.h> par exemple) dans un fichier source.

En fait, avant la compilation, le préprocesseur parcourt tous les fichiers sources et remplace les directives par le
contenu du fichier inclus.

Les constantes du préprocesseur ou constantes symboliques

Dr Guy MBATCHOU 2
Programmation
Séquence 2 : Objectif 27 : Manipuler le préprocesseur et compiler un programme contenu dans plusieurs fichiers

La directive define permet de définir une constante du préprocesseur. Sa syntaxe est la suivante :

#define Nom_Constante Valeur_Constante

Remarquez qu’à la fin de la directive define, il n’y a pas de « ; »

Ne pas confondre une constante du préprocesseur et une constante (const float pi = 3,14 ;) telle que vu
précédemment. Les constantes occupent de l’espace en mémoire bien que leur valeur ne puisse être changée alors
que les constantes du préprocesseur n’occupent pas. Avant la compilation, les constantes du préprocesseur sont
remplacées par leur valeur.

Ces constantes du préprocesseur nous permettent d’éviter de fixer les valeurs dans nos programmes : il est plus facile
de lire un programme contenant une constante de préprocesseur (chaîne de caractère explicite) qu’un programme
contenant une valeur. De plus, si la valeur représentée par la constante du préprocesseur doit être modifiée, on la
modifie juste dans la directive du processeur sans se soucier du reste du programme Une utilité de cette constante du
préprocesseur se verra lors de la déclaration des tableaux puisque la taille d’un tableau ne peut être ni une variable, ni
une constante.

Il est possible de définir des constantes du préprocesseur contenant des calculs à base des opérations de base telle
que l’addition, la soustraction, la multiplication, la division et le modulo. Dans ce cas, il faut mettre vos expressions
entre parenthèses.

Exemple :

#define TAILLE_MOYENNE 175 //taille exprimée en centimètre

#define MASSE_MOYEN 80 //masse exprimée en kilogramme
#define IMC_MOYEN (MASSE_MOYEN / (TAILLE_MOYENNE * TAILLE_MOYENNE)) //IMC = Indice de
Masse Corporelle
Il est fortement recommandé que les constantes symboliques soientt en lettres majuscules.

Il existe aussi des constantes de préprocesseur sans valeur :

#define Nom_Constante
Elle permet juste de savoir que la constante est tout simplement définie. Son intérêt sera mis en exergue lorsque nous
définirons plus loin les conditions dans les directives du préprocesseur.

Les macros
Une macro est un ensemble d’instructions auquel un identificateur est affecté pour l’identifier. Une macro contient un
nombre faible d’instructions simples (pas complexes). Une macro est introduite par define et respecte la syntaxe
suivante :

#define NOM_MACRO(paramètre1, …, paramètre P) instruction 1 ; \

instruction 2 ; \
…\
instruction N ;
Le nom de la macro est suivi des parenthèses ouvrante et fermante même si la macro n’a pas de paramètre. Les
paramètres de la macro n’ont pas de type.

Si la macro dispose de plusieurs instructions que vous voulez mettre sur plusieurs lignes, il faut absolument précéder la
nouvelle ligne du caractère antislash « \ »

Exemple : Macro sans paramètre

#define LIEU() printf("Nous sommes à l’Université Virtuelle du Sénégal") ;

Exemple : Macro avec paramètres

Dr Guy MBATCHOU 3
Programmation
Séquence 2 : Objectif 27 : Manipuler le préprocesseur et compiler un programme contenu dans plusieurs fichiers

#define ADRESSE(Nom, Ville) \

Printf("%s habite la ville %s", Nom, Ville) ;
Lors de l’utilisation de la macro, elle est appelée comme une fonction. Le processeur remplace le nom de la macro par
le code associé avant la compilation. Si la macro est paramétrée alors le paramètre est remplacé par la valeur d’appel.

Les conditions
Le langage du préprocesseur contient des instructions conditionnelles permettant d’exécuter des instructions sous
certaines conditions.

#if condition 1
Instructions du code source à compiler si la condition est vraie
#else
Instructions du code source à compiler si la condition est fausse
#endif
S’il y a plusieurs conditions, on aura :

#if condition 1
Instructions du code source à compiler si la condition 1 est vraie
#elif condition 2
Instructions du code source à compiler si la condition 2 est vraie
#elif condition 3
Instructions du code source à compiler si la condition 3 est vraie
#endif
Pour éviter les inclusions multiples des fichiers d’entête annoncées précédemment, on utilise les constantes
symboliques sans valeur. La première inclusion définira la constante et à la seconde et autre, on testera si la constante
symbolique est définie ou non et l’inclusion se fera en fonction. Pour cela le langage du préprocesseur dispose de
#ifdef (avec optionnellement #elifdef) et #ifndef (avec optionnellement #elifndef) permettant respectivement de
tester si une constante est définie ou non.

Dans le fichier d’entête, les prototypes ou déclarations de fonctions sont conditionnés par une constante symbolique

Exemple : Réalisation d’une mini-calculatrice

Le fichier d’entête nommé « Entete.h » est le suivant :

#ifndef ENTETE
#define ENTETE

double Addition(double, double);

double Soustraction(double, double);
double Multiplication(double, double);
double Division(double, double);
#endif // ENTETE
L’interprétation du code ci-dessus est le suivant : lors de l’inclusion du fichier Entete.h, si la constante symbolique
ENTETE est non définie alors on la définit et inclut les prototypes des fonctions. Si par hasard, dans le même
programme, ce fichier est inclus une seconde fois, les prototypes ne seront plus inclus car la constante symbolique
ENTETE sera déjà définie pour montrer que les prototypes ont été déjà inclus.

Le fichier source nommé « Entete.c » est le suivant :

Dr Guy MBATCHOU 4
Programmation
Séquence 2 : Objectif 27 : Manipuler le préprocesseur et compiler un programme contenu dans plusieurs fichiers

#include<float.h>
#include "Entete.h"

double Addition(double a, double b){

return a+b;
}

double Soustraction(double a, double b){

return a-b;
}

double Multiplication(double a, double b){

return a*b;
}

double Division(double a, double b){

if (b==0) return FLT_MAX; //Infini
else return a/b;
}
Un extrait du fichier contenant la fonction principale est le suivant :

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

int main()
{
double A, B, R;

printf("Addition des double\n");

printf(" Valeur A: ");
scanf("%lf",&A);
printf(" Valeur B: ");
scanf("%lf",&B);
R = Addition(A,B);
printf("Résultat = %lf", R);
return 0;
}

Seuil de validation : 80% Titre : Test de connaissance Objectifs visés : O27(20%)

Seuil de validation : 60% - Titre : Réalisation d’un programme avec un menu séparé en plusieurs
fichiers sources Objectifs visés : O27(90%)

Dr Guy MBATCHOU 5