ÉCOLE NATIONALE D’INGÉNIEURS ENI-ABT

DER: Génie Informatique et Télécommunication (GIT)

UE: Algorithme & Structure de données 2 CLASSE: L2S3

Durée : 3h00 30-05-2024

TP N° 1
I. Objectifs :
Le but de ce TP est dans un premier temps de faire découvrir aux apprenants l’Environnement de
Développement Intégré (EDI) Code::Blocks et par la suite les initier à l’utiliser pour créer de nouveaux
projets.

Logiciel open-source spécialement conçu pour la programmation, Code::Blocks dispose d'un

environnement de développement intégré en C et C++. Ce compilateur, Code::Blocks est
multiplateformes et multi-langages et ceux-ci lui permet être un efficace outil de développement de
diverses applications avec de différents langages de programmation. Il propose une multitude d'outils
pour un travail de développement sur n'importe quelle plateforme.

II. Principales fonctionnalités

Code::Blocks est un environnement de développement gratuit et multiplateforme (Linux et Windows),
développé pour coller au mieux aux demandes des utilisateurs. Conçu autour d'une architecture de
plugins, il est ainsi extensible et configurable très facilement ce qui lui permet d'évoluer très vite. L'un de
ses principaux atouts est de pouvoir s'interfacer avec la plupart des compilateurs gratuits du marché : VC+
+ toolkit, MinGW… Une version contenant MinGW est d'ailleurs disponible si vous ne possédez pas
encore de compilateur.
Il est entièrement libre en GPLv3, sans aucun coût caché. Il est possible de l'utiliser sur n'importe quelle
plateforme en utilisant des wxWidgets. Comme c'est entièrement écrit en C++, il n'est pas utile d'utiliser
des langages d'interprétation ou de charger une librairie propriétaire. On peut augmenter sa potentialité en
y ajoutant des plug-ins. Code::Blocks est téléchargeable avec le compilateur intégré MinGW, préinstallé
(version Win32 de GCC). Il est aussi capable de supporter plusieurs compilateurs, à savoir MSVC++,
Digital Mars, Borland C++ 5.5 et bien plus encore. Les opérations de compilation peuvent se faire très
rapidement. Si on a un processeur puissant, il est possible de faire des compilations en parallèle. Il
propose une interface GNU GDB pour faciliter le débogage.
Pour éviter les erreurs au moment de l'écriture d'un programme, il dispose d'un système qui affiche les
symboles et les arguments. Code::Blocks permet de personnaliser le vidage de la mémoire. En standard,
Code::Blocks dispose d'un environnement visuel de création rapide de programmes avec interfaces
graphiques, WxSmith fonctionnant sous Linux, Mac OS X et Windows, et utilisable après installation de
la bibliothèque libre et multiplateforme wxWidgets, avec laquelle Code::Blocks lui même est réalisé.

1/4
 III. Installation :
Suivant la plateforme et le type de distribution l’installation diffère. On trouve les différentes distributions
de Code::Blocks à l’adresse suivante (la version dernière actuelle stable 20.03, est parue le 19/03/2020) :
http://wiki.codeblocks.org/index.php?title=Compiled_packages_of_Code::Blocks
Depuis la version 1.0 RC2, de nombreuses améliorations ont été introduites et l’interface a beaucoup
évolué. C’est pourquoi il est préférable d’utiliser ces versions en attendant la prochaine release candidate.
Il existe deux distributions pour Windows, la distribution sans compilateur et la distribution intégrant
le compilateur GNU gcc (distribution minGW). Les distributions sont des exécutables Windows qui ne
soulèvent aucune difficulté particulière d’installation; installer la version comprenant minGW si on ne
dispose pas du compilateur GCC sous Windows.
Il existe des distributions de binaires pour différents linux : Gentoo, Fedora, Freebsd, Ubuntu, ....
Attention, sous linux, l’interface graphique de Code::Blocks s’appuie sur les bibliothèques wxGTK qu’il
faut donc se procurer par ailleurs : http://dag.wieers.com/packages/wxGTK/
Etapes d’installation :
 Télécharger l’installateur de Code::Blocks (https://codeblocks.org/downloads/
26). Si vous n’avez pas MinGW d’installé, ou si vous ne savez pas lequel choisir, télécharger la version
qui intègre MinGW. Pour une version 20.03, le nom de l’installateur est : codeblocks-20.03mingw-
setup.exe. La version précédente était identifiée par 17.12.
 Lancez l’installateur. C’est un installateur standard pour Windows ; pressez seulement sur Next
(ou Suivant) après avoir lu chaque écran.
IV. Prise en main de Code::Blocks
Une fois l’installation de Code::Blocks réussie, vous le lancez en double clinquant son raccourcis sur le
bureau. La première opération consiste à créer un nouveau projet :
A) Création d’un nouveau projet
1) Cliquez sur Create new project soit en cliquant sur New project dans le menu File (raccourci clavier
Ctl-Shift-n). Une fenêtre dialogue New from template s’ouvre et vous demande de choisir un modèle de
projet : Il existe des modèles prédéfinis de projets et on peut également choisir de créer seulement des
fichier (.h, .cpp).
2) On choisit Application Console, une fenêtre nommée Application console s’ouvre dans laquelle on
vous souhaite la bienvenue, cliquez sur Next pour continuer.
3) Dans la nouvelle fenêtre, on décide si l’on développe une application C ou C++ (sélectionnez le C, puis
cliquez sur Next). Par défaut, des fichiers sont créés (leur nombre dépendant du modèle de projet).
4) L’enregistrement du projet est effectué dans la fenêtre surgissant en spécifiant le nom du projet et le
dossier où il sera sauvé : dans Project Title : saisissez Projet1 et dans Folder to create project in
saisissez C:\ENI-ABT\GIT\L2S3\TP1

2/4
5) Cliquez Next, pour passer à la fenêtre du choix du compilateur à utiliser (par défaut GNU GCC
compiler) et les versions qui seront générées, par défaut Debug (permettant de faire du suivi d’exécution)
et Release (version sabs option de débogage) puis clic Finish sans rien changer. Pour une Application
Console, seul un fichier main.c minimaliste est créé (programme "Hello word!").
6) Dans le volet Project apparait l’arborescence Workspace des projets et en particulier celui qui vient
d’être créé. En cliquant sur le dossier Sources, le fichier source main.c apparait.
7) Double cliqué ce dernier fichier, il sera affiché dans une fenêtre centrale d’édition avec mis en
évidence de la syntaxe C. On peut modifier le code source de façon immédiate avec des actions standards
d’un éditeur et la souris.
A tout moment le projet peut être sauvé en cliquant sur l’icône représentant une disquette ou ouvrir le
menu File qui offre plusieurs commandes de sauvegarde.
B) Exploration du nouveau projet
A ce stade, le projet peut déjà être compilé et exécuté.
1) Pour le compiler, il suffit de cliquer sur la commande Build du menu Build (raccourci clavier Ctl-F9)
qui va enchainer les opérations de compilation et d’édition de liens, générant ainsi un fichier exécutable
(Projet1.exe dans notre exemple) ; Les éventuels avertissements, messages d’erreur et l’état final du
processus de compilation apparaissent dans l’onglet Build log situé en bas. Lorsqu’il y a des erreurs,
l’onglet Build messages indique les lignes en cause et en cliquant sur le message d’erreur on est
positionné dans l’éditeur sur la ligne en cause.
2) Pour exécuter le code, il suffit de cliquer sur la commande Run du menu Build (raccourci clavier Ctl-
F10), une fenêtre d’exécution s’ouvre alors (application console).
3) On peut enchainer la compilation et l’exécution en cliquant sur la commande Build & Run du menu
Build (raccourci clavier F5).
C) Débogage du nouveau projet
1) Code::blocks offre des possibilités de débogage interactives. Il faut tout d’abord placer au moins un
point d’arrêt sur une des lignes du code, soit en cliquant sur la colonne de gauche, soit en invoquant le
menu contextuel (click bouton de droite) et en cliquant sur Toggle breakpoint au niveau de la ligne de
code; un point rouge devrait apparaitre.
2) Ensuite on lance l’exécution du programme à l’aide de la commande Start du menu Debug : le
programme s’arrête sur la première ligne rencontrée qui possède un point d’arrêt (un curseur apparait).
3) A ce stade, on peut consulter le contenu des variables actives dans la fenêtre Watches que l’on fait
apparaitre en cochant la case Watches dans le menu Debugging windows : La fenêtre Watches fournit
par défaut le contenu des variables actives et on peut en rajouter d’autres à l’aide du menu contextuel de
l’éditeur.
4) On peut aussi dérouler l’exécution suivant différents modes : commandes Step over (F7), Step into
( Shift-F7) ou Step out (Ctl-Shift-F7) et Abort du menu Debug ou via les boutons d’accès rapide.

3/4
V. Mise en application :

Appliquez la méthodologie précédente sur l’exercice ci-dessous, en s aisissant le programme C ci-dessous puis
compilez, exécutez et commentez les résultats dans un fichier MS Word.

Exercice :

Algorithme GesEtud #include <stdio.h>

Type Etud = Enregistrement #include <string.h>
Mle : Entier ; typedef struct etud
Nom[30] : caractere ; { int Mle; char nom[20], prenom[20];
Prénom[20] : caractere ; }etud;
Fin Etud ; etud ET[2];
Variable ET[9] : Etud ; int n;
n: Entier ; void remplissage(int n, etud t[2])
Procédure Remplissage(m : Entier; var T : Etud) { int i;
Var i : Entier ; for(i=0; i<=n; i++) {
Début printf("Etudiant numero: %d",i); printf("\n");
Pour (i ← 0 à m ) faire printf("Mle:"); scanf("%d", &t[i].Mle);
Ecrire("Etudiant n°", i," :") ; printf("\nNom:"); scanf("%s", t[i].nom);
Ecrire("Mle : ") ; Lire(T[i].Mle) ; printf("\nPrenom:"); scanf("%s", t[i].prenom); }
Ecrire("Nom : ") ; Lire(T[i].Nom) ; }
Ecrire("Prénom : ") ; Lire(T[i].Prénom) ; void affichage(int n, etud t[2])
Fin Pour {
Fin ; int i;
Procédure Affichage(m : Entier ; var T : Etud) printf("\nMle Nom Prenom:\n");
Var i : Entier ; printf("----------------------------------\n");
Début for(i=0; i<=n; i++) {
Ecrire("Mle, Nom, Prénom : ") ; printf("\n%d %s %s %s %s",t[i].Mle," ", t[i].nom,"
Ecrire("----------------------------------------") ", t[i].prenom); } printf("\n");
Pour (i ← 0 à m) faire }
Ecrire(T[i].Mle,"",Lire(T[i].Nom," ",T[i].Prénom) ;
Fin Pour int main()
Fin ; { n = 2;
{Programme principal} remplissage(n, ET);
Début affichage(n, ET);
n ← 9 ; Remplissage(n, ET) ; Affichage(n, ET) ; return 0;
Fin. }

4/4