La programmation

modulaire

Paternité - Partage des Conditions Initiales à l'Identique : http://creativecommons.org

/licenses/by-sa/4.0/fr/
 Table des
matières
I - La programmation modulaire 3

1. Rappel ............................................................................................................................................................. 3

2. Les headers ..................................................................................................................................................... 4

2.1. Les headers .................................................................................................................................................................................. 4

3. La compilation ................................................................................................................................................ 7
3.1. Le préprocesseur .......................................................................................................................................................................... 7
3.2. La compilation ............................................................................................................................................................................. 7
3.3. Édition de liens ............................................................................................................................................................................ 7

4. La portée des fonctions et variables ................................................................................................................ 8

4.1. Les variables propres aux fonctions ............................................................................................................................................. 8
4.2. Les variables globales .................................................................................................................................................................. 9
4.3. Variable statique à une fonction ................................................................................................................................................ 10
4.4. Les fonctions locales à un fichier ............................................................................................................................................... 11
 La programmation modulaire

La programmation
modulaire I

1. Rappel
Rappel : Le prototype d'une fonction
Le prototype d'une fonction indique :

- son nom ;
- le nombre de paramètres d'entrée et le type de chacun d'entre eux ;
- le type de résultat en sortie.

Les noms de paramètre sont optionnels, mais il est fortement conseillé de les laisser. Cela donne une bonne
indication sur leurs rôles.

Une fonction qui n'utilise pas de paramètres a comme prototype :

[typeRes] nomFonction( ) ou bien [typeRes] nomFonction(void).

Exemples :

int puissance (int, int ) ;

double conversion(double dinars) ;

void function_1(int x) ;

int function_2(void) ;

3
2. Les headers
2.1. Les headers
Jusqu'ici, nous n'avions qu'un seul fichier source dans notre projet. Ce fichier source est « main.c ».

2.1.1. Plusieurs fichiers par projets

Nos programmes peuvent être tous écrits dans ce même fichier « main.c », mais ce n'est jamais très pratique
d'avoir un fichier de 1000 lignes. C'est pour cela qu'en général on crée plusieurs fichiers par projet.

Un projet, c'est l'ensemble des fichiers source de votre programme. Pour le moment, nos projets n'étaient
composés que d'un fichier source. Regardez dans votre IDE, généralement c'est sur la gauche.

Exemple
Ce projet n'est composé que d'un fichier « main.c ».

Exemple
Un vrai projet ressemblera à ça : on verra plusieurs fichiers dans la colonne de gauche.

- Le fichier « main.c » : c'est celui qui contient la fonction main.

- Les fichiers portant l'extension « .h »
- Les fichiers portant l'extension « .c »

Remarque
Ce n'est pas une obligation qu'on ne met que la fonction main dans « main.c ». Chacun s'organise comme il
veut.

4
 En général, on regroupe dans un même fichier des fonctions ayant le même thème. Ainsi, :

- dans le fichier « fonctions_saisies.c », on a regroupé toutes les fonctions concernant les opérations de
saisie ;
- dans le fichier « fonctions_calculs.c », on a regroupé toutes les fonctions concernant les calculs ;
- dans le fichier « fonctions_affichages.c , on a regroupé toutes les fonctions concernant les opérations
d'affichage ;

2.1.2. Fichiers .h et .c

Il y a deux types de fichiers différents (figure précédente) :

- Les « .h » : appelés fichiers headers. Ces fichiers contiennent les prototypes des fonctions.
- Les « .c » : les fichiers source. Ces fichiers contiennent les fonctions elles-mêmes.

En général, on met donc rarement les prototypes dans les fichiers « .c ».

Remarque
Pour chaque fichier « .c » ,il y a son équivalent « .h » qui contient les prototypes des fonctions.

Exemple

- il y a« fonctions_saisies.c » (le code des fonctions) et « fonctions_saisies.h » (les prototypes des

fonctions) ;
- il y a « fonctions_calculs.c » et « fonctions_calculs.h »;
- il y a « fonctions_affichages.c » et « fonctions_affichages.h ».

Quand on fait appel à une fonction,on doit déjà la connaître, savoir combien de paramètres elle prend, etc. On
doit inclure donc son prototype.

Pour cela, on doit inclure, dans le fichier « .c », les fichiers « .h » qui contiennent les prototypes des fonctions à
utiliser dans ce fichier « .c ».

Méthode
L'inclusion du fichier « .h » se fait grâce à la directive de préprocesseur #include.

La commande #include demande d'insérer le contenu du fichier « .h » dans le « .c ».

5
 Exemple

1 #include <stdlib.h>
2 #include <stdio.h>
3 #include "fonctions_saisies.h"
4
5 int main()
6{
7 // ...
8}

Remarque
On utilise :

- les < > pour inclure les bibliothèques (des fichiers se trouvant dans le répertoire « include » de l'IDE) ;
- les " " pour inclure un fichier se trouvant dans le répertoire du projet (à côté des fichiers « .h » ,
généralement).

2.1.3. Les include des bibliothèques standard

Les bibliothèques standard (par exemple « stdio.h » et « stdlib.h ») se trouvent dans le dossier d'installation de
l'IDE. Il faut généralement chercher un dossier include. Ce dernier contient de très nombreux fichiers. Ce sont
des headers (.h) des bibliothèques standard.

Exemple
C:\Program Files\CodeBlocks\MinGW\include

Remarque
Les fichiers « .c » qui contiennent le code source de ces fonctions sont déjà compilés (en code binaire, c'est-à-
dire en code machine). Il est donc totalement impossible de les lire.

On peut retrouver les fichiers compilés dans un répertoire appelé lib (c'est l'abréviation de library qui signifie «
bibliothèque »).

Exemple
C:\Program Files\CodeBlocks\MinGW\lib

Ces fichiers compilés ont l'extension « .a » sous Code::Blocks.

6
3. La compilation

3.1. Le préprocesseur
Le préprocesseur est un programme qui démarre avant la compilation. Son rôle est d'exécuter les instructions
spéciales qu'on lui a données dans des directives de préprocesseur, ces lignes qui commencent par un #.

Il met à l'intérieur de chaque fichier « .c » le contenu des fichiers « .h » qu'on a demandé d'inclure. Le fichier «
.c » devient donc complet et contient tous les prototypes des fonctions qu'on utilise.

3.2. La compilation
Cette étape consiste à transformer les fichiers source en code binaire compréhensible par l'ordinateur. Le
compilateur compile les fichiers « .c » un à un. Il compile tous les fichiers source du projet.

Le compilateur génère un fichier « .o » (ou « .obj », ça dépend du compilateur) par fichier « .c » compilé.

3.3. Édition de liens

Le linker (ou « éditeur de liens » en français) est un programme dont le rôle est d'assembler les fichiers binaires
« .o ». avec les bibliothèques compilées dont on a besoin (« .a » ou « .lib » selon le compilateur).

Il les assemble en un seul gros fichier : l'exécutable final.

7
4. La portée des fonctions et variables
La notion de portée des fonctions et des variables consiste à déterminer quand les variables et les fonctions sont
accessibles, c'est-à-dire quand on peut faire appel à elles.

4.1. Les variables propres aux fonctions

Une variable déclarée dans une fonction n'existe que pendant que la fonction est exécutée. Elle est donc
supprimée de la mémoire à la fin de la fonction. On dit que c'est une variable locale.

Exemple

1 int triple(int nombre)

2{
3 int resultat = 0;
4
5 resultat = 3 * nombre;
6 return resultat;
7}
8
9 int main()
10 {
11 printf("Le triple de 15 est %d\n", triple(15));
12
13 printf("Le triple de 15 est %d", resultat); // Erreur
14
15 return 0;
16 }

Dans le main, on essaie d'accéder à la variable resultat. Or, comme cette variable resultat a été créée dans la
fonction triple, elle n'est pas accessible dans la fonction main.

8
4.2. Les variables globales
4.2.1. Variable globale accessible uniquement dans un fichier

Une variable globale est accessible par toutes les fonctions écrites en‐dessous de sa définition dans le même
fichier source.

On fait généralement la déclaration tout en haut du fichier, après les #include.

Exemple

1 #include <stdio.h>
2
3 int resultat = 0; // Déclaration de variable globale
4
5 void triple(int nombre)
6{
7 ...
8}
9
10 int main()
11 {
12 ...
13 return 0;
14 }
15

La variable resultat sera accessible dans TOUTES les fonctions de ce fichier (triple, main).

4.2.2. Variable globale accessible dans tous les fichiers

Une variable globale est accessible par toutes les fonctions écrites en‐dessous de sa définition dans le même
fichier source. Mais une fonction écrite dans un autre fichier ne peut pas se servir de cette variable globale.

Pour résoudre ce problème, le langage C prévoit une déclaration qui précise que la variable globale est définie
dans un autre fichier. C'est la déclaration extern.

Syntaxe
extern type nom_var ;

Cette déclaration indique au compilateur qu'il ne s'agit pas d'une nouvelle variable et qu'il ne doit pas réserver
de place en mémoire. La déclaration extern fournit le type de la variable et précise qu'elle est déjà définie
ailleurs.

Exemple

1 #include <stdio.h>
2
3 int glob=20;
4
5 int main()
6{
7 ...
8 return 0;
9}

9
 10

1 #include <stdio.h>
2
3 void fonctionExemple()
4{
5 extern int glob;
6 printf("glob = %d\n",glob);
7}
8

4.2.3. Restreindre l'accès à une variable globale

Il est possible de rendre une variable globale accessible uniquement dans le fichier dans lequel elle se trouve.

Pour créer une variable globale accessible uniquement dans un fichier, on ajoute simplement le mot-clé static
devant.

Exemple

1 static int resultat = 0;

Remarque
L'utilisation conjointe des deux mots clés extern et static est donc impossible.

4.3. Variable statique à une fonction

Une variable déclarée dans une fonction avec le mot-clé static devant n'est pas supprimée à la fin de la
fonction, elle conserve sa valeur au fur et à mesure de l'exécution du programme.

Exemple : Exemple 1

1 int triple(int nombre)

2{
3 static int resultat = 0; // La variable resultat est créée la première fois
que la fonction est appelée
4
5 resultat = 3 * nombre;
6 return resultat;
7 } // La variable resultat n'est PAS supprimée lorsque la fonction est terminée.

Lorsqu'on appelle la fonction triple plus tard, la variable resultat contiendra toujours la valeur de la dernière
fois.

Exemple : Exemple 2

1 int incremente()
2{
3 static int nombre = 0;
4
5 nombre++;
6 return nombre;
7}
8

10
 9 int main()
10 {
11 printf("%d\n", incremente());
12 printf("%d\n", incremente());
13 printf("%d\n", incremente());
14 printf("%d\n", incremente());
15
16 return 0;
17 }

- La première fois qu'on appelle la fonction incremente, la variable nombre est créée et initialisée à 0. Elle
est incrémentée à 1, et une fois la fonction terminée la variable n'est pas supprimée.
- Lorsque la fonction est appelée une seconde fois, la ligne de la déclaration de variable est tout simplement
« sautée ». On ne recrée pas la variable, on réutilise la variable qu'on avait déjà créée (1). Elle est donc
incrémentée à 2.
- Lorsque la fonction est appelée une troisième fois, la variable nombre devient 3.
- Lorsque la fonction est appelée une quatrième fois, la variable nombre devient 4.

4.4. Les fonctions locales à un fichier

Lorsqu'on crée une fonction, celle-ci est globale à tout le programme. Elle est accessible depuis n'importe quel
autre fichier « .c » dans le projet (après l'ajout du fichier header « .h » correspondant).

Si on veut créer des fonctions qui ne seront accessibles que dans le fichier dans lequel se trouve la fonction, on
ajoute le mot-clé static devant la fonction (dans la définition et le prototype).

Exemple

1 static int triple(int nombre)

2{
3 // Instructions
4}

1 static int triple(int nombre);

La fonction static triple ne peut être appelée que depuis une autre fonction du même fichier. Si on essaie
d'appeler la fonction triple depuis une fonction d'un autre fichier, ça ne marchera pas car triple n'y sera pas
accessible.

11