Projet C 2P/3B ESPRIT 2019-2020

Atelier 0: Initiation aux Outils de Développement C sous Linux

1. Objectifs
− Initiation à l'utilisation de quelques outils de développement avec le langage C sous
Linux.
− Développement en C sous Linux à partir d'un terminal (en mode console).

NB: l'utilisation de tout IDE tel que codeblocks est strictement interdite.

2. Pré-requis
Pour réaliser cet atelier, on doit disposer d’une machine virtuelle Linux Ubuntu.

3. Outils de Développement
GCC (GNU Compiler Collection) est une suite de logiciels libres de compilation utilisé dans le
monde Linux dès qu’on veut transcrire du code source en langage machine. Il est le plus
répandu des compilateurs. La suite gère le C et ses dérivés mais aussi le Java ou encore le
Fortran.

Make Gestionnaire de Compilation (Make) permet d'automatiser la phase de compilation,

celle du programme mais aussi celle de la documentation associée. Il permet aussi
d'automatiser l'installation, la mise en paquetage pour distribuer plus facilement
l’application, l'élimination de fichiers temporaires créés par votre éditeur de texte et le
compilateur.

GDB (Gnu DeBugger) est un debugger puissant dont l'interface est totalement en ligne de
commande, c'est-à-dire avec une invite en texte. Il est tellement apprécié qu'on le trouve
aussi encapsulé dans des interfaces graphiques comme XXGDB ou DDD. GDB est publié sous
la licence GNU et est gratuit. Il permet la localisation des erreurs en spécifiant des points
d’arrêt. GDB vérifie aussi le bon fonctionnement du programme ligne par ligne en consultant
les états et le contenu des variables.

1
Projet C 2P/3B ESPRIT 2019-2020

4. Préparation de l'Environnement
Démarrer la machine virtuelle Linux Ubuntu.

Lancer un terminal (ctrl + alt + t).

Vérifier l’existence des outils GCC, Make et GDB dans le système d'exploitation à l’aide des
commandes suivantes:

gcc - - version
make - - version
gdb - - version

Figure 1: Versions des Outils GCC, Make et GDB

Si les outils GCC, Make et GDB ne sont pas installés par défaut, alors taper la commande
suivante:

sudo apt-get update && sudo apt-get install build-essential gdb

2
Projet C 2P/3B ESPRIT 2019-2020

5. Développement C sous Linux

Le développement d’un programme C sous Linux à partir d'un terminal passe par 3 phases:
− Édition ou écriture du code.
− Compilation du code afin de créer un binaire (exécutable sur la machine).
− Exécution du binaire et débogage en cas d'erreur de segmentation.

5.1. Édition du Code Source

La première phase de développement en n'importe quel langage de programmation est

l'édition ou la rédaction du code moyennant un éditeur de texte. Dans un terminal (en mode
console), une panoplie d'éditeurs existe. L'éditeur le plus facile à utiliser est nano. En mode
graphique, il existe un éditeur préinstallé appelé gedit.

Si l'éditeur nano n'est pas installé, alors taper dans un terminal la commande suivante:

sudo apt-get install nano

Lancer un terminal (ctrl + alt + t).

Éditer un fichier main.c avec la commande suivante:

nano main.c (sinon gedit main.c)

Écrire le code suivant:

#include <stdio.h>
int main() {
int a;
int b;
printf("\nSaisie du Premier Nombre: ");
scanf("%d", &a);
do {
printf("\nsaisie du Second Nombre: ");
scanf("%d", &b);
} while(b == 0);
printf("\n%d + %d= %d", a, b, a + b);
printf("\n%d - %d= %d", a, b, a - b);
printf("\n%d / %d = %f\n", a, b, (float) a / b);
return (0);

3
Projet C 2P/3B ESPRIT 2019-2020

Taper (ctrl + o) pour enregistrer et (ctrl + x) pour quitter l’éditeur.

5.2. Compilation du Code Source

Dans le même terminal, taper la commande qui permet de compiler le fichier main.c:

gcc main.c -o programme

main.c est le fichier source et programme est le binaire (exécutable) résultant de l'opération
de compilation.

5.3. Exécution du Fichier Binaire

Afin de lancer l'exécution du fichier binaire issu de la compilation du code source main.c,
taper dans le même terminal la commande:

./programme

6. Compilation de Plusieurs Fichiers Sources

4
Projet C 2P/3B ESPRIT 2019-2020

Figure 2: Compilation Multiple-Fichiers en C

Garder le même terminal actif, on dispose à présent du fichier main.c.

Créer deux nouveaux fichiers nommés fonctions.c et fonctions.h:

touch fonctions.c fonctions.h

Éditer le fichier fonctions.c et copier dedans le code suivant:

int sommer(int a, int b) {

return (a + b);
}
int soustraire(int a, int b) {
return (a - b);
}
float diviser(int a, int b) {
return ((float) a / b);
}

Éditer le fichier fonctions.h et copier dedans les prototypes des fonctions implémentés dans
fonctions.c:

#ifndef FONCTIONS_H_
#define FONCTIONS_H_
int sommer(int a, int b);
int soustraire(int a, int b);
float diviser(int a, int b);
#endif

5
Projet C 2P/3B ESPRIT 2019-2020

Les lignes vertes sont ajoutées pour éviter le problème d’inclusion circulaire.

Il ne faut pas oublier d'ajouter #include ''fontions.h'' dans main.c et d'évoquer les fonctions
de ce module.

Compiler chaque module à part:

gcc -c main.c
gcc -c fonctions.c

L'option -c permet de compiler le fichier en question sans passer à la phase d'édition de

lien.

Taper la commande ls afin de lister le contenu du répertoire courant, vous allez

remarquer la création des deux fichiers fonctions.o et main.o (deux fichiers objets)
comme résultat de la phase de compilation.

La dernière phase après la compilation est de lier les fichiers objets en un seul fichier
binaire exécutable (prog) moyennant l'option –o:

gcc main.o fonctions.o -o prog

Enfin on peut exécuter le binaire résultant, en tapant la commande:

./prog

7. Automatisation de la Compilation sous Linux

Afin d'automatiser la compilation de plusieurs fichiers sources, il faut utiliser make qui est
un outil très général permettant, entre autre, d'automatiser la compilation d'un projet. Il suffit
de décrire les relations dans le fichier makefile, ainsi que les commandes associées pour qu'il
puisse produire la séquence de commandes correcte.

7.1. Création du Fichier makefile

Le fichier makefile est celui dans lequel on met les commandes qui seront exécutées par
l'outil make. Il est constitué des descriptions et des relations entre les fichiers sources et les
fichiers objets ainsi que des relations entre les fichiers objets et l'exécutable (règles). Une
règle est constituée des composantes suivantes:

Cible : dépendances
<tab> commande

Dans le même terminal, créer un fichier intitulé makefile:

6
Projet C 2P/3B ESPRIT 2019-2020

touch makefile

Éditer les règles suivantes dans le fichier makefile:

nano makefile

prog:fonctions.o main.o
gcc fonctions.o main.o -o prog
main.o:main.c
gcc -c main.c
fonctions.o:fonctions.c
gcc -c fonctions.c

Il faut ajouter une tabulation et non pas un espace avant chaque commande gcc du fichier
makefile

Enregistrer le fichier makefile et quitter nano (ctrl + o et ctrl + x).

Compiler le projet en invoquant l'outil make:

make

Exécuter la cible prog:

./prog

8. Exécution et Débogage
Éditer à nouveau le fichier makefile contenant les règles de compilation:

nano makefile

Ajouter l'option -g à chaque fois qu’on évoque la commande gcc, enregistrer le

fichier makefile ensuite quitter:

prog:fonctions.o main.o
gcc fonctions.o main.o -o prog -g
main.o:main.c
gcc -c main.c -g
fonctions.o:fonctions.c
gcc -c fonctions.c –g

7
Projet C 2P/3B ESPRIT 2019-2020

Rééditer le fichier main.c et remplacer le code précédent par le code qui présente un bug lors
de l’exécution.

#include <stdio.h>
#include "fonctions.h"
int main() {
int a;
int b;
printf("\nSaisie du Premier Nombre: ");
scanf("%d", a);
do {
printf("\nsaisie du Second Nombre: ");
scanf("%d", b);
} while(b==0);
printf("\n%d + %d = %d", a, b, sommer(a, b));
printf("\n%d + %d = %d", a, b, soustraire(a, b));
printf("\n%d / %d = %f\n", a, b, diviser(a, b));
return (0);
}

Recompiler à nouveau le projet:

make (la compilation sera faite sans problèmes)

Exécuter le binaire résultant prog:

./prog

8
Projet C 2P/3B ESPRIT 2019-2020

Figure 3: Bug lors de l’Exécution du Binaire prog

Lors de l'exécution, un message s'affiche: ''erreur de segmentation'' sans aucune indication

sur la nature et l'emplacement de l'erreur, puisqu’on est en phase d'exécution du binaire prog.

La seule façon de trouver les erreurs en cours d'exécution est de débogueur le binaire prog
grâce au débuggeur GDB:

gdb prog

9
Projet C 2P/3B ESPRIT 2019-2020

Figure 4: Lancement du Débogueur GDB

Une fois l'interface du GDB lancée, taper dans le prompt la commande run ou taper r.
Des informations sur l’erreur s'affichent mais elles ne sont pas précises. Dans cet
exemple, on peut dire que l'utilisation de la fonction scanf à causer l’erreur.

10
Projet C 2P/3B ESPRIT 2019-2020

Figure 5: Opération de Débogage

On peut faire mieux en localisant la ligne causant l'erreur dans le code, il suffit de taper
la commande where dans le prompt du GDB:

11
Projet C 2P/3B ESPRIT 2019-2020

Figure 6: Localisation du Bug

Les Breakpoints:

On peut exploiter gdb pour examiner le programme à différentes étapes de son exécution.
Pour cela, il faut introduire des points d’arrêt où l’exécution s’interrompra.

Un point d'arrêt "Breakpoint" arrête l'exécution d'un programme et renvoie le contrôle au

débogueur, où ses variables peuvent être examinées avant de continuer.

Exemple:

(gdb) break 3: permet d'arrêter l'exécution à la ligne 3.

On peut également fournir le nom d’une fonction. L’exécution s’interrompra alors à chaque
appel de cette fonction.
(gdb) b Somme: 6 : permet de faire un breakpoint dans la fonction Somme, à la ligne 6.

Exemple d’Utilisation des Breakpoints:

Commande 1: nano main.c

#include <stdio.h>
int main()
{
int x = 0;
printf("x = ");
scanf("%d", x);
return (0);
}

Commande 2: gcc main.c –o programme –g

Commande 3: gdb programme

Commande 4: (gdb) b 6

Commande 5: (gdb) r

12
Projet C 2P/3B ESPRIT 2019-2020

Figure 7: Placement d’un Point d’Arrêt

Examiner la situation lors d’un Breakpoint:

Lorsque l’exécution du programme est interrompue suite à un point d'arrêt, on peut
examiner l’état de la mémoire à ce moment là, par exemple en affichant la valeur d’une
variable à l’aide de la commande print :
Commande 6: (gdb) p x

13
Projet C 2P/3B ESPRIT 2019-2020

Figure 8: Affichage du Contenu d’une Variable

On peut également utiliser la commande list pour se remémorer l’endroit dans le code où
l’exécution a été interrompue.
Effacer un Breakpoint:
La commande clear en indiquant un numéro de ligne ou un nom de fonction permet
d'effacer le breakpoint.
Commande 7: (gdb) clear 6

La commande delete permet aussi d'effacer un breakpoint en indiquant son numéro (delete
tout court efface – après confirmation – tous les points d’arrêt).
Commande 8: (gdb) quit

14
Projet C 2P/3B ESPRIT 2019-2020

Figure 9: Effacer un point d'arrêt

Résumé: Quelques commandes importantes sous gdb

(gdb) run ou « r »: lancer le débogage.

(gdb) quit ou « q »: quitter gdb.
(gdb) break ou « b »: placer des points d'arrêt en précisant le numéro de la ligne ou le nom de
la fonction.
(gdb) print ou « p » : afficher le contenu d’une variable.
(gdb) next ou « n » : passer à la ligne suivante.
(gdb) continue ou « c »: relance l’exécution jusqu’au prochain point d’arrêt.

Tableau Récapitulatif:

commande rôle
nano main.c édition
gcc main.c -o programme compilation
gcc -c main.c compilation sans édition de lien
gcc main.c –o programme –g compilation avec débogage
make automatisation de la compilation
gdb programme débogage
./programme exécution

15