Apprenez à
programmer avec Ada
Par Kaji9
www.openclassrooms.com
Licence Creative Commons 6 2.0
Dernière mise à jour le 7/10/2013
Sommaire
2 Sommaire ...
9 Lire aussi ...
11 Apprenez à programmer avec Ada ...
12 Partie 1 : Premiers pas avec Ada ...
12 Programmation, algorithmique et Ada ? ...
12 Qu'est-ce qu'un programme ? ...
12 Qu'appelle-t-on programme ? ...
13 Alors qu'allons-nous faire ? ...
13 Comment réaliser un programme ? ...
13 Pourquoi Ada et pas autre chose ? ...
13 Algorithmique ...
14 Pourquoi Ada ? ...
14 En résumé : ...
15 Les logiciels nécessaires ...
15 IDE et compilateur : kesako ? ...
15 Le compilateur ...
15 L'IDE ou EDI ...
15 Télécharger et installer Adagide. ...
15 Téléchargement ...
15 Installation ...
15 Télécharger et installer GNAT. ...
15 Téléchargement ...
15 Installation ...
16 Télécharger et installer GPS ...
16 En résumé : ...
16 Notre premier programme en Ada ...
17 Découvrir son IDE en quelques secondes ...
17 Soyons rapide avec Adagide ...
17 Pour les utilisateurs de GPS (plus long) ...
18 Notre premier programme ...
18 Un petit copier-coller ! ...
18 Compiler, créer… lancer ! ...
18 Mon dieu, qu'ai-je fait ? ...
19 Le corps du programme : la procédure Hello ...
19 Les Packages avec With et Use ...
20 Une dernière remarque qui a son importance ...
20 Exercices ...
20 Exercice 1 ...
20 Exercice 2 ...
20 Exercice 3 ...
21 En résumé : ...
22 Partie 2 : Ada, notions essentielles ...
22 Variables I : Typage et affectation ...
22 Déclaration de variables ...
22 Différents types ...
22 Les types Integer et Natural ...
23 Le type Float ...
24 Le type Character ...
24 Affectation ...
25 Affectation par le programmeur (ou le programme) ...
25 Affectation par l'utilisateur ...
25 L'instruction Skip_line ...
25 Compléments ...
26 Constantes ...
26 Attributs ...
26 Bloc de déclaration ...
27 En résumé : ...
28 Variables II : Opérations ...
28 Opérations sur les Integer et les Natural ...
28 Opérations sur les float ...
28 Opérations élémentaires ...
28 Ne faites pas d'erreur de casting ...
28 Opérations mathématiques ...
29 Opérations sur les character ...
29 Exercices ...
29 Exercice 1 ...
29 Exercice 2 ...
30 Exercice 3 ...
30 Exercice 4 ...
30 En résumé : ...
30 Les conditions I ...
31 Conditions simples avec IF ...
31 Un début en douceur ...
31 Une première alternative ...
2/312
31 Conditions multiples avec IF ...
32 Conditions multiples avec CASE ...
32 Tester de nombreux cas ...
32 Ne rien faire ...
32 Les opérateurs de comparaison et d'appartenance ...
32 Les opérateurs de comparaison ...
33 L'opérateur d'appartenance ...
33 Pour les utilisateurs de la norme Ada2012 ...
33 Les expressions IF ...
34 Les expressions CASE ...
34 Toujours plus complexe ...
34 En résumé : ...
34 Les conditions II : les booléens ...
35 Introduction aux booléens ...
35 Un bref historique ...
35 Qu'est-ce qu'un booléen ? ...
35 Les opérateurs booléen ...
35 La négation avec Not ...
36 Les opérations Or et And ...
36 L'instruction OR ...
36 L'instruction AND ...
36 L'opération XOR (optionnel) ...
36 Exercice ...
37 Priorités booléennes et ordre de test (Supplément) ...
37 Priorités avec les booléens ...
37 Ordre de test ...
38 En résumé : ...
39 Les boucles ...
39 La boucle Loop simple ...
39 Principe général ...
39 Arrêter une itération ...
40 Nommer une boucle ...
40 La boucle While ...
40 La boucle For ...
41 Les antiquités : l'instruction goto ...
41 Boucles imbriquées ...
41 Méthode avec une seule boucle (plutôt mathématique) ...
41 Méthode avec deux boucles (plus naturelle) ...
42 Exercices ...
42 Exercice 1 ...
42 Exercice 2 ...
42 Exercice 3 ...
42 Exercice 4 ...
42 Exercice 5 ...
42 Exercice 6 ...
42 En résumé : ...
43 Procédures et fonctions I ...
43 Les procédures ...
43 Procédure sans paramètre ...
44 Procédure avec un paramètre (ou argument) ...
44 Procédure avec plusieurs paramètres (ou arguments) ...
45 Les fonctions ...
45 Une bête fonction ...
46 Une fonction un peu moins bête (optionnel) ...
47 Bilan ...
47 Prédéfinir ses paramètres ...
48 In, Out, In Out ...
48 Paramètres de procédure ...
49 Paramètres de fonction ...
49 En résumé : ...
49 [TP] Le craps ...
50 Les règles du craps ...
50 Cahier des charges ...
50 Simuler le hasard (ou presque) ...
51 Un plan de bataille ...
51 Une solution ...
52 Pistes d'amélioration : ...
53 Partie 3 : Ada, les types composites ...
53 Les tableaux ...
53 Les types composites, c'est quoi ? ...
53 Tableaux unidimensionels ...
53 Problème ...
54 Création d'un tableau en Ada ...
55 Attributs pour les tableaux ...
56 Tableaux multidimensionels ...
56 Tableaux bidimensionnels ...
56 Tableaux tridimensionnels et plus ...
57 Et mes attributs ? ...
57 Et mes agrégats ? ...
57 Des tableaux un peu moins contraints ...
57 Un type non-contraint ou presque ...
57 Affectation par tranche ...
Sommaire 3/312
58 Déclarer un tableau en cours de programme ...
58 Quelques exercices ...
58 Exercice 1 ...
59 Exercice 2 ...
59 Exercice 3 ...
60 Pour les utilisateurs de la norme Ada2012 ...
60 Boucle FOR OF ...
61 Expressions quantifiées ...
61 En résumé : ...
61 Les chaînes de caractères ...
62 Présentation des Chaînes de Caractères ...
62 Déclaration et affectation d'un string ...
62 Quelques opérations sur les strings ...
62 Accès à une valeur ...
62 Accès à plusieurs valeurs ...
63 Modifier la casse ...
63 Concaténation ...
63 Transformer une variable en string et inversement ...
63 Comparaison ...
64 Saisie au clavier ...
64 Chaînes de caractères non contraintes ...
64 Déclarer des strings illimités ! ...
64 Opérations sur les unbounded_string ...
65 En résumé : ...
66 La programmation modulaire I : les packages ...
66 Les fichiers nécessaires ...
66 Notre première procédure… empaquetée ...
68 Variables et constantes globales ...
68 Trouver et classer les fichiers ...
68 Les packages fournis avec GNAT ...
68 Organiser nos packages ...
69 Petite astuce pour limiter les fichiers générés ...
69 Compléter notre package (exercices) ...
69 Cahier des charges ...
70 Solutions ...
72 Vecteurs et calcul vectoriel (optionnel) ...
72 Qu'est-ce exactement qu'un T_Vecteur ? ...
72 Calcul vectoriel ...
73 En résumé : ...
73 Les fichiers ...
74 Ouvrir / Fermer un fichier texte ...
74 Package nécessaire ...
74 Le type de l'objet ...
74 Fermer un fichier ...
74 Ouvrir un fichier ...
75 Le paramètre Mode ...
75 Lecture seule ...
75 Écriture seule ...
75 Ajout ...
75 Opérations sur les fichiers textes ...
75 Mode lecture seule : In_File ...
77 Mode écriture : Out_File / Append_File ...
77 Autres opérations ...
77 Les fichiers binaires séquentiels ...
78 Les fichiers binaires directs ...
79 Les répertoires ...
79 Chemins absolus et relatifs ...
79 Indiquer le chemin d'accès ...
79 Gérer fichiers et répertoires ...
80 Quelques exercices ...
80 Exercice 1 ...
80 Exercice 2 ...
80 Exercice 3 ...
81 En résumé : ...
82 Créer vos propres types ...
82 Créer à partir de types prédéfinis ...
82 Sous-type comme intervalle ...
82 Types modulaires ...
82 Énumérer les valeurs d'un type ...
83 Les types structurés ...
83 Déclarer un type «construit» ...
84 Ordre des déclarations ...
84 Déclarer et modifier un objet de type structuré ...
85 22 ! Rev'là les tableaux ! ...
85 Les types structurés : polymorphes et mutants ! ...
85 Les types structurés polymorphes ...
86 Les types structurés mutants ...
88 En résumé : ...
89 [TP] Logiciel de gestion de bibliothèque ...
89 Cahier des charges ...
89 Quelles données pour quels types de données ? ...
89 Quelle architecture pour les fichiers ...
Sommaire 4/312
89 Quelles fonctionnalités pour quelles fonctions et procédures ? ...
89 Architecture du code source ...
90 Conception du programme (suivez le guide) ...
90 Création des types ...
90 Affichage d'une œuvre ...
90 Saisie d'une oeuvre ...
90 Gestion des fichiers ...
91 Les commandes ...
91 Solutions possibles ...
95 Pistes d'amélioration : ...
96 Les pointeurs I : allocation dynamique ...
96 Mémoire, variable et pointeur ...
97 Le type access ...
97 Déclarer un pointeur ...
97 Que contient mon pointeur ? ...
97 Comment accéder aux données ? ...
98 Opérations sur les pointeurs ...
98 Une erreur à éviter ...
98 Libération de la mémoire ...
98 Un programme (un peu) gourmand ...
99 Un problème de mémoire ...
100 Résolution du problème ...
101 Exercices ...
101 Exercice 1 ...
101 Exercice 2 ...
101 En résumé : ...
101 Les pointeurs II ...
102 Cas général ...
102 Pointeurs généralisés : pointer sur une variable ...
102 Pointeur sur une constante et pointeur constant ...
103 Pointeur sur pointeur ...
103 Pointeur comme paramètre ...
104 Pointeur sur un programme (optionnel) ...
104 Un exemple simple ...
104 Un exemple de la vie courante ...
105 Un exemple très… mathématique ...
106 Exercices ...
106 Exercice 1 ...
106 Exercice 2 ...
107 Exercice 3 ...
107 Exercice 4 ...
107 Exercice 5 (Niveau Scientifique) ...
108 En résumé : ...
108 Fonctions et procédures II : la récursivité ...
109 Une première définition ...
109 Exemple d'algorithme récursif ...
110 Notre première fonction récursive ...
110 Énoncé ...
110 Indications ...
110 Une solution possible ...
111 Algorithme de recherche par dichotomie ...
111 Principe ...
111 Mise en œuvre ...
111 Solution ...
112 Quelques exercices ...
112 Exercice 1 ...
112 Exercice 2 ...
112 Exercice 3 ...
113 Exercice 4 ...
113 En résumé : ...
113 Les Types Abstraits de Données : listes, files, piles… ...
114 Qu'est-ce qu'un Type Abstrait de Données ? ...
114 Un premier cas ...
114 Autres cas ...
115 Primitives ...
115 Les piles ...
115 Création du type T_Pile ...
116 Création des primitives ...
117 Jouons avec le package P_Pile ...
118 Les files ...
118 Implémentation ...
119 Amusons-nous encore ...
119 Les listes chaînées ...
119 Quelques rappels ...
120 Le package Ada.Containers.Doubly_Linked_Lists ...
121 Le package Ada.Containers.Vectors ...
122 En résumé : ...
124 [TP] Le jeu du serpent ...
124 Cahier des charges ...
124 Fonctionnalités ...
124 Organisation des types et variables ...
124 Un package bien utile ...
Sommaire 5/312
124 Le package NT_Console ...
129 Le contenu en détail ...
130
… et encore un autre ! ...
130 Quelques indications ...
130 Jouer en temps réel ...
131 Comment afficher un serpent et une zone de jeu en couleur ? ...
131 Par où commencer ? ...
131 Une solution possible ...
135 Pistes d'amélioration : ...
135 Partie 4 : Ada : Notions avancées et Programmation Orientée Objet ...
136 Algorithmique : tri et complexité ...
136 Algorithmes de tri lents ...
136 Tri par sélection (ou par extraction) ...
137 Tri par insertion ...
137 Tri à bulles (ou par propagation) ...
138 Algorithmes de tri plus rapides ...
138 Tri rapide (ou Quick Sort) ...
138 Tri fusion (ou Merge Sort) ...
139 Tri par tas ...
142 Théorie : complexité d'un algorithme ...
142 Complexité ...
142 L'écriture O ...
142 Quelques fonctions mathématiques ...
143 Mesures de complexité des algorithmes ...
143 Un algorithme pour mesurer la complexité… des algorithmes ...
144 Traiter nos résultats ...
145 En résumé : ...
146 Variables III : Gestion bas niveau des données ...
146 Représentation des nombres entiers ...
146 Le code binaire ...
146 Conversions entre décimal et binaire ...
147 Retour sur le langage Ada ...
148 Représentation du texte ...
149 Représentation des nombres décimaux en virgule flottante ...
149 Représentation des float ...
150 Implications sur le langage Ada ...
151 En résumé : ...
152 La programmation modulaire II : Encapsulation ...
152 Qu'est-ce qu'un objet ? ...
152 Une première approche ...
152 Posons le vocabulaire ...
153 De nouvelles contraintes ...
153 Un package… privé ...
153 Partie publique / partie privée ...
154 Visibilité ...
155 Un package privé et limité ...
155 Que faire avec un type PRIVATE ? ...
155 Restreindre encore notre type ...
156 Exercices ...
156 Exercice 1 ...
156 Exercice 2 ...
156 En résumé : ...
156 La programmation modulaire III : Généricité ...
157 Généricité : les grandes lignes ...
157 Que veut-on faire ? ...
157 Plan de bataille ...
157 Un dernier point de vocabulaire ...
157 Créer et utiliser une méthode générique ...
157 Créer une méthode générique ...
158 Utiliser une méthode générique ...
159 Paramètres génériques de types simples et privés ...
159 Types génériques simples ...
159 Types génériques privés ...
159 Paramètres génériques de types composites et programmes ...
159 Tableaux génériques ...
160 Pointeurs génériques ...
160 Paramètre de type programme : le cas d'un paramètre LIMITED PRIVATE ...
161 Packages génériques ...
161 Exercice ...
162 Solution ...
162 Application ...
163 En résumé : ...
163 La programmation modulaire IV : Héritage et dérivation ...
164 Pour bien commencer ...
164 Héritage : une première approche théorique ...
164 Héritage : une approche par l'exemple ...
165 Héritage ...
165 Héritage de package simple ...
166 Héritage avec des packages privés ...
167 Héritage avec des packages génériques ...
168 Dérivation et types étiquetés ...
168 Créer un type étiqueté ...
Sommaire 6/312
168 Et nos méthodes ? ...
170 Un autre avantage des classes ...
170 En résumé : ...
170 La programmation modulaire V : Polymorphisme, abstraction et héritage multiple ...
171 Polymorphisme ...
171 Méthodes polymorphes ...
171 Objets polymorphes ...
173 Abstraction ...
173 Types abstraits ...
173 Méthodes abstraites ...
174 Héritage multiple ...
174 Comment Ada gère-t-il l'héritage multiple ? ...
175 Réaliser des interfaces Ada ...
177 En résumé : ...
177 La programmation modulaire VI : Finalisation et types contrôlés ...
178 Objectifs et prérequis ...
178 De quoi parle-t-on exactement ? ...
178 Comment s'y prendre ? ...
178 Mise en œuvre ...
179 Mise en place de nos types ...
179 Mise en place de nos méthodes ...
180 En résumé : ...
181 [TP] Bataille navale ...
181 Règles du jeu ...
181 Le déroulement ...
181 Les navires ...
181 Les statistiques ...
181 Cahier des charges ...
181 Gameplay ...
181 Les calculs ...
182 POO ...
182 Une solution possible ...
182 L'organisation ...
182 Le code ...
194 Pistes d'amélioration : ...
194 Les exceptions ...
195 Fonctionnement d'une exception ...
195 Vous avez dit exception ? ...
195 Le fonctionnement par l'exemple ...
195 Traitement d'une exception ...
195 Le bloc EXCEPTION ...
196 Où et quand gérer une exception ...
196 Exceptions prédéfinies ...
196 Exceptions standards ...
197 Autres exceptions prédéfinies ...
197 Créer et lever ses propres exceptions ...
197 Déclarer une exception ...
197 Lever sa propre exception ...
198 Propagation de l'exception ...
198 Rectifier son code ...
199 Assertions et contrats ...
199 Assertions ...
200 Programmation par contrats (Ada2012 seulement) ...
200 En résumé : ...
201 Multitasking ...
201 Parallélisme, tâches et types tâches ...
201 Multitasking ou l'art de faire plusieurs tâches à la fois ...
201 Les tâches en Ada ...
203 Le type tâche ...
204 Communication inter-tâche directe ...
204 Le parallélisme, comment ça marche ? ...
205 Les entrées ...
206 Les synchronisations sélectives ...
206 Gardes et compléments ...
207 Communication inter-tâche indirecte ...
207 Les types protégés ...
208 Les sémaphores ...
209 Les moniteurs ...
210 Compléments : priorités et POO ...
210 Priorités ...
211 Quand la programmation orientée objet rejoint la programmation concurrente ...
212 Programme multitâche et processeur multicœur (Ada 2012 uniquement) ...
212 Exercices fondamentaux ...
212 Modèle des producteurs et consommateurs ...
213 Modèle des lecteurs et rédacteurs ...
215 Le dîner des philosophes ...
216 En résumé : ...
216 Interfaçage entre Ada et le C ...
217 Quelques préparatifs ...
217 Logiciels nécessaires ...
217 Quelques rudiments de C ...
218 Packages nécessaires ...
Sommaire 7/312
218 Hello World : du C à l'Ada ...
218 Notre programme en C ...
218 Notre programme Ada avec les normes 95 ou 2005 ...
219 Notre programme Ada avec la norme 2012 ...
219 Quelques menus problèmes ...
219 Procédure avec paramètres ...
220 Avec un type structuré ...
221 En résumé : ...
222 Partie 5 : Ada et GTK : la programmation évènementielle ...
222 GTKAda : introduction et installation ...
222 Vous avez dit GTK ? ...
222 Qu'est-ce que GTK ? ...
222 GTK, GTKAda, GDK, Glib et toute la famille ...
223 Pourquoi ce choix ? ...
223 Télécharger et installer GTKAda ...
223 Télécharger ...
224 Installer ...
224 Configurer votre IDE ...
225 Un premier essai ...
225 En résumé : ...
225 Votre première fenêtre ...
226 Analysons notre code ...
226 Code GtkAda minimal ...
226 Créer une fenêtre ...
227 Personnaliser la fenêtre ...
227 Changer de type de fenêtre ...
227 Définir les paramètres avec Set_# ...
229 Ajout d'un widget ...
229 Qu'est-ce qu'un widget ? ...
229 Ajouter un bouton ...
230 Personnaliser le bouton ...
230 Ajouter un second bouton ? ...
231 Retour sur la POO ...
231 Méthode brutale ...
231 Méthode subtile ...
232 En résumé : ...
232 Les conteneurs I ...
233 Des conteneurs pour… contenir ! ...
233 Qu'est-ce qu'un conteneur ? ...
233 Présentation de différents conteneurs ...
234 Les alignements ...
234 Fiche d'identité ...
234 Créer un GTK_Alignment ...
235 Le padding ...
236 Les boîtes ...
236 Boîtes classiques ...
239 Boîtes à boutons ...
240 Les tables ...
240 Fiche d'identité ...
240 Créer une table de widgets ...
241 Ajouter des widgets ...
241 Les paramètres supplémentaires ...
242 Le widget pour position fixe ...
242 Fiche d'identité ...
242 Utilisation des GTK_Fixed ...
242 En résumé : ...
244 Les signaux ...
244 Le principe ...
244 Les problèmes de la programmation évènementielle ...
244 Le principe Signal-Procédure de rappel ...
244 Connecter un signal à un callback ...
244 Fermer proprement le programme ...
245 Utiliser le bouton ...
246 Interagir avec les widgets ...
246 Un callback à deux paramètres ...
247 Un nouveau package de callbacks ...
247 La connexion ...
248 Perfectionner encore notre code ...
249 Autres packages de callback ...
249 GDK et les événements ...
249 Le clic droit ...
250 Le double clic ...
251 Le clavier ...
252 En résumé : ...
253 Les widgets I ...
253 Les étiquettes ...
253 Fiche d'identité ...
253 Quelques méthodes des GTK_Label ...
254 Pour une mise en forme plus poussée ...
255 Les images ...
255 Fiche d'identité ...
255 Méthodes ...
Sommaire 8/312
256 Exercice : créer un bouton avec icône ...
257 Les zones de saisie ...
257 La saisie de texte sur une ligne : les entrées ...
258 Saisie de texte multiligne ...
263 Saisie numérique ...
263 Saisie numérique par curseur ...
264 D'autres boutons ...
264 Boutons à bascule ...
264 Boutons-liens ...
265 Boutons à cocher ...
265 Boutons radios ...
265 Widgets divers ...
266 Les séparateurs ...
266 Les flèches ...
266 Le calendrier ...
267 Les barres de progression ...
267 En résumé : ...
267 Les Widgets II : les boîtes de dialogue ...
268 Message ...
268 Fiche d'identité ...
268 Méthodes ...
268 Les signaux ...
269 À propos ...
269 Fiche d'identité ...
269 Méthodes ...
270 Sélection de fichier ...
270 Fiche d'identité ...
270 Méthodes des GTK_File_Chooser_Dialog ...
271 Les GTK_File_Chooser (sans le Dialog) ...
272 Deux widgets supplémentaires ...
272 Signaux des Gtk_File_Chooser ...
272 Sélection de police ...
272 Fiche d'identité ...
272 Méthodes ...
273 Sélection de couleur ...
273 Fiche d'identité ...
273 Méthodes ...
273 Signaux ...
273 Cas général ...
273 Fiche d'identité ...
273 Méthodes ...
273 Signaux ...
274 En résumé : ...
275 [TP] Le démineur ...
275 Règles du jeu et cahier des charges ...
275 Quelques rappels ...
275 Règles retenues ...
275 Quelques ressources ...
275 Un petit coup de main ...
275 Premier objectif : détruire une case ...
276 Second objectif : placer un drapeau ...
276 Troisième objectif : passer du bouton unique à la grille ...
276 Quatrième objectif : destruction de cases en cascade ...
276 Une solution possible ...
276 Les spécifications ...
278 Le corps des packages ...
281 La procédure principale ...
281 Pistes d'amélioration : ...
281 Les conteneurs II ...
282 Les onglets ...
282 Fiche d'identité ...
282 Méthodes ...
284 Les barres de défilement ...
284 Fiche d'identité ...
284 Exemples d'utilisation ...
286 Méthodes ...
286 Les panneaux ...
286 Fiche d'identité ...
287 Méthodes ...
287 Les cadres ...
287 Les cadres simples ...
288 Les cadres d'aspect ...
288 Les extenseurs ...
288 Fiche d'identité ...
288 Méthodes ...
289 Les boîtes détachables ...
289 Fiche d'identité ...
289 Méthodes ...
289 En résumé : ...
289 Les widgets III : barres et menus ...
290 La barre de menu ...
290 Créer une barre de menu ...
290 Créer et ajouter des items ...
Sommaire 9/312
291 Créer et ajouter un menu déroulant ...
292 Améliorer la barre de menu ...
292 Créer un menu en image ...
292 Créer un sous-menu ...
293 Proposer un item à cocher dans le menu ...
294 Organiser vos menus ...
294 La barre d'icônes ...
294 Fiches d'identité ...
294 Créer notre barre d'icônes ...
295 Améliorer les barres d'icônes ...
296 Combiner menus et icônes ...
297 La barre de statut ...
297 Fiche d'identité ...
297 Méthodes et fonctionnement ...
298 Exemples d'utilisation ...
299 Le menu déroulant ...
299 Fiche d'identité ...
299 Méthodes ...
300 Menu déroulant avec saisie ...
300 En résumé : ...
300 [TP] Démineur (le retour) ...
301 Cahier des charges ...
301 Objectifs ...
301 Widgets nécessaires ...
301 Une solution possible ...
301 Les spécifications ...
305 Le corps des packages ...
310 La procédure principale ...
310 Pistes d'amélioration : ...
Lire aussi 10/312
Apprenez à programmer avec Ada
Par Kaji9
Mise à jour : 07/10/2013
Difficulté : Intermédiaire Durée d'étude : 2 mois 5 visites depuis 7 jours, classé 16/807
Vous voudriez apprendre à programmer mais ne savez pas par où commencer ? Vous avez commencé à apprendre un autre langage mais vous vous embrouillez dans les accolades et autres symboles bizarroïdes ? Ou encore vous souhaitez apprendre un nouveau langage de programmation ? Alors ce tutoriel est fait pour vous.
Le langage Ada est certainement le meilleur langage pour apprendre à programmer : pour peu que vous connaissiez deux ou trois mots d'anglais, il vous sera facile de lire un code en Ada. Moins abstrait que beaucoup de langages, mais toutefois rigoureux, facilement compréhensible et lisible, même par un novice, le langage Ada vous permettra de comprendre les logiques propres à la programmation et vous donnera tout de suite de bonnes habitudes.
Qui plus est, le langage Ada ne présente ni plus ni moins de fonctionnalités que les langages les plus connus (C, C++, Java, Python…). Il est seulement différent et, je me répète, plus accessible aux débutants. Alors si vous êtes intéressé, nous allons pouvoir débuter de tutoriel. Celui-ci est organisé en cinq parties :
La partie I constitue une introduction à la programmation et vous accompagne dans votre première prise en main d'Ada.
Les parties II, III et IV traitent du langage Ada en lui-même et présenteront une difficulté progressive : notions de base, types composites puis programmation orientée objet.
La partie V constitue une mise en pratique en vous proposant de créer des programmes fenêtrés avec GTK et Ada.
Le cours sera ponctué de travaux pratiques. Ce sont des chapitres vous proposant un projet (parfois ludique) allant du logiciel de gestion de vos DVD à des jeux de dés ou de démineur. Ils seront pour vous l'occasion de mettre en application vos connaissances acquises.
Lire aussi 11/312
Partie 1 : Premiers pas avec Ada
Dans cette toute première partie, la plus courte, nous allons poser les bases en répondant à quelques question existentielles : qu'est-ce que la programmation ? Quelle différence avec l'Algorithmique ? Qu'est-ce qu'un langage de programmation ? Comment faire pour «programmer en Ada» ? Nous verrons également comment installer les quelques logiciels nécessaires ainsi que leur fonctionnement. Enfin, nous créerons notre tout premier programme en Ada et tenterons de comprendre comment ceux-ci sont organisés.
Programmation, algorithmique et Ada ?
Nous allons dans ce chapitre répondre à quelques questions préliminaires. Qu'est-ce qu'un programme ? À quoi cela ressemble-t- il ? Comment crée-t-on un programme ? Qu'est-ce que l'algorithmique ? Pourquoi utiliser Ada et non pas un autre langage ? Ce que j'apprends ici sera-t-il utilisable avec un autre langage ?
Bref, beaucoup de réponses existentielles trouveront (je l'espère) leur réponse ici. Ce chapitre, relativement court et sans difficultés, permettra de poser un certain nombre d'idées et de termes. Pour bien commencer, mieux vaut en effet que nous ayons le même vocabulaire.
À ceux qui auraient déjà des notions de programmation, vous pouvez bien entendu éviter ce chapitre. Je ne saurais trop toutefois vous conseiller d'y jeter un œil, histoire de remettre quelques idées au clair.
Qu'est-ce qu'un programme ?
Avant de commencer, il est important que nous nous entendions sur les termes que nous allons utiliser.
Qu'appelle-t-on programme ?
Les programmes sont des fichiers informatiques particuliers. Sous Windows, ce sont généralement des fichiers se terminant par l'extension .exe ; sous MacOS ce sont globalement des fichiers .app ; sous Linux ce sont schématiquement des fichiers .bin.
Cette explication est très (TRÈS) schématique, car d'autres types de fichiers peuvent correspondre à des programmes.
Ces fichiers ont comme particularité de ne pas seulement contenir des données, mais également des instructions. Lorsque vous ouvrez un fichier .exe sous windows, celui-ci transmet à votre ordinateur une liste de tâches à effectuer comme :
ouvrir une fenêtre afficher du texte effectuer des calculs
…
Cette liste d'instructions envoyées au processeur, forme alors ce que l'on appelle un processus.
On fait généralement un amalgame entre programme et processus. Le programme est, rappelons-le, un fichier. Le processus correspond aux instructions effectuées par le processeur et qui viennent du programme. Mais, en général, on appelle tout cela programme.
Vous trouverez ci-dessous trois exemples de programmes.
Mozilla Firefox
Calculatrice de Windows
Paint Shop Pro
Attention, tous les programmes ne sont pas nécessairement visibles. Beaucoup n'ouvrent même pas de fenêtre ! Pour s'en rendre compte, sous Windows, appuyez simultanément sur les touches Alt + Ctrl + Suppr, puis cliquez sur le second onglet, cela affichera la liste de tous les processus en cours.
Apprenez à programmer avec Ada 12/312
Gestionnaire des tâches
de Windows
Bon nombre d'entre eux effectuent des tâches tranquillement sans que vous ne vous en rendiez compte.
Alors qu'allons-nous faire ?
Eh bien, programmer (en Ada ou avec tout autre langage) c'est tout simplement créer des programmes. Mais je vous arrête tout de suite, malgré tout le talent de votre humble guide, vous ne confectionnerez pas un jeu vidéo en 3D d'ici la fin de ce tutoriel. La plupart des logiciels, comme le navigateur internet que vous utilisez actuellement, exigent la participation de nombreuses personnes et de nombreuses autres compétences ne relevant pas de ce cours (modélisation 3D par exemple). Les premiers programmes que nous allons concevoir seront des programmes en console. C'est-à-dire qu'ils ressembleront à la figure suivante.
Programme en console
Nous ne pourrons utiliser que le clavier ! Pas de souris ou de joystick ! Pas d'images ou de vidéos ! Pas de 3D puisqu'il n'y aura même pas de 2D ! Que du texte blanc sur fond noir.
Aaargh ! Mais, c'est possible ? Ces horreurs existent encore ?
Bon, c'est vrai qu'aujourd'hui on a tendance à oublier la console, mais il est nécessaire de passer par ce stade pour apprendre les bases de la programmation. Nous pourrons ensuite nous atteler à des programmes plus conséquents (avec des boutons, des images, la possibilité d'utiliser la souris… ). Mais il faudra être patient.
Comment réaliser un programme ?
Alors comment faire pour créer votre propre programme ? Il faut avant tout savoir comment est constitué un programme (ou tout autre type de fichier). Vous le savez peut-être déjà, mais un ordinateur a un langage très très basique. Il ne connaît que deux chiffres : 1 et 0 ! Donc tout fichier (et donc tout programme) ne peut ressembler qu'à ceci :
10001001111010110110111011011 ...
Ça rappelle Matrix ! Mais comment je fais moi ? J'y comprends rien à tous ces chiffres! Il faut faire Math Sup pour afficher une fenêtre ?
Pas d'inquiétude : personne n'est capable de créer un programme informatique ainsi. C'est pourquoi ont été inventés différents langages pour la programmation : le Pascal, le Basic, le C, le C++, le Python, le Java… et bien sûr l'Ada. Ce sont ce que l'on appelle des langages de haut niveau. À quoi cela ressemble-t-il ?
Voyez vous-même : Code : Ada
with Ada.Text_IO, Ada.Integer_Text_IO ; use Ada.Text_IO, Ada.Integer_Text_IO ; procedure exemple is
n : integer ; begin loop
Put("Saisir un nombre : ") ; Get(n) ; Skip_line ; if n mod 2 = 0
then Put("Ce nombre est pair ! Tres bien !") ; exit ; else Put("Ce nombre est impair ! Recommencez. ") ; end if ;
end loop ; end exemple ;
Vous serez capables d'ici quelques chapitres de comprendre ce texte aisément. C'est comme apprendre une langue étrangère ; d'ailleurs si vous connaissez l'anglais, vous avez peut-être reconnu quelques mots : end, if, else, then, begin et is. C'est ainsi que nous créerons nos programmes.
Et comment on traduit ça en 1 et en 0 ?
Une fois notre texte rédigé en Ada (mais c'est aussi valable pour les autres langages), il faudra utiliser un programme-traducteur pour le convertir en un programme lisible par l'ordinateur. Les programmes-traducteurs sont appelés compilateurs.
Pourquoi Ada et pas autre chose ? Algorithmique
Il ne vous reste donc plus qu'à apprendre un langage de programmation, et avec ce langage, vous apprendrez également ce que l'on appelle l'algorithmique.
Algorithmique ? Qu'est-ce que c'est que ça encore ?
Partie 1 : Premiers pas avec Ada 13/312
L'algorithmique est une branche des mathématiques qui traite de la résolution de problèmes à l'aide d'instructions simples. J'en vois déjà certains qui paniquent à la vue du mot «Mathématiques», mais n'ayez crainte vous avez déjà vu plusieurs fois dans votre vie des algorithmes. Par exemple, comment faire pour diviser 742 par 5 ? Vous vous souvenez, c'était en primaire ? Vous aviez appris à vous demander : «dans 7 combien de fois 5 ? Il y va 1 fois et il reste 2». Puis vous répétiez cette opération : «dans 24 combien de fois 5 ? Il y va 4 fois et il reste 4»… Il suffisait de répéter plusieurs fois cette méthode basique pour obtenir le résultat désiré (Voir la figure suivante).
La division illustrée
Eh bien ça, c'était un algorithme : vous répétiez des instructions simples dans un certain ordre (abaisser les chiffres de 742, se demander «dans machin, combien de fois truc ?»…) afin de résoudre un problème plus compliqué («Combien vaut
?»). Et tout programme informatique n'est en fait qu'un algorithme écrit dans un langage compréhensible par votre ordinateur.
Donc apprendre à programmer, c'est en fait apprendre la science de l'algorithmique dans un langage informatique donné.
Pourquoi Ada ?
Mais alors, pourquoi apprendre Ada et pas simplement l'algorithmique ? Et pourquoi utiliser Ada et pas un autre langage ?
Tout d'abord, l'algorithmique n'est pas compréhensible par les ordinateurs, je vous rappelle que c'est une science. L'algorithme de la division euclidienne vu au-dessus est expliqué en français, or je vous ai dit qu'il doit être écrit dans un langage qui pourrait être traduit par un compilateur, un langage très structuré et normé (qui ne changera pas en changeant de compilateur), et ça, c'est ce qu'on appelle la programmation. Et Ada répond à ces exigences.
Au début, on parlait d'Ada tout court ou d'Ada83. Puis le langage a évolué, donnant naissance aux normes Ada95 puis Ada2005 et enfin Ada2012. Mais rassurez-vous, tout cela ne constitue qu'une sorte de «grosse mise à jour» et pas 3 langages différents ! C'est pourquoi nous ne parlerons pas ici des langages Ada83, Ada95 ou Ada2005 mais simplement du langage Ada.
Maintenant, pourquoi utiliser Ada et non pas un autre langage ? Il est vrai que Ada n'est pas le langage le plus répandu. Mais il présente de nombreux avantages par rapport à d'autres langages plus courants comme le C, le C++, le Java…
Tout d'abord il présente un avantage pédagogique. Ada consitue un langage parfait pour apprendre à programmer. D'ailleurs de nombreuses écoles ou universités l'utilisent comme support de leurs cours de programmation. La rigueur qu'il impose au programmeur permet aux débutants d'apprendre à coder correctement, de prendre de bonnes habitudes qu'ils conserveront par la suite, même s'ils venaient à changer de langage de programmation durant leur carrière. Qui plus est, c'est un langage facilement lisible car il utilise des mots complets (begin, end, function, if… c'est de l'anglais en effet) plutôt que les symboles
«barbares et bizarroïdes» pour un débutant que préfèrent la plupart des langages actuels. Les codes des programmes sont certes moins condensés, mais plus faciles à reprendre en cas de bogue ce qui constitue un avantage non négligeable quand on sait que les coûts de maintenance d'un logiciel sont souvent plus élevés que le coût de son développement.
Ensuite, le langage présente également des avantages pour les professionnels. Son fort typage (vous aurez l'occasion de le découvrir durant la deuxième partie) ou sa très bonne gestion des erreurs (abordée lors de la quatrième partie) garantissent des programmes fiables. Ce n'est pas pour rien qu'Ada est utilisé pour de gros projets comme Ariane, chez Thalès pour ses avions ou radars, ou encore pour la sécurité des centrales nucléaires, du trafic aérien ou ferroviaire… Utiliser Ada est un gage de fiabilit é et pour cause, il a été développé par le polytechnicien français Jean Ichbiah pour le compte du département de la défense américain, le fameux DoD (vous vous doutez bien que rien n'a été laissé au hasard ).
Maintenant que ces quelques explications préliminaires sont faites, j'espère que vous vous sentez toujours prêts à vouloir apprendre un langage. Si cela vous semble compliqué, n'ayez crainte, nous commencerons doucement et je vous guiderai pas à pas. Nos premiers programmes seront peut-être inutiles ou ringards, mais nous apprendrons peu à peu de nouvelles notions qui nous permettront de les perfectionner.
En résumé :
Un programme est un fichier contenant des instructions à destination du processeur de votre ordinateur.
Un programme est écrit en langage binaire, le seul langage que comprend votre ordinateur.
Pour réaliser un programme, vous devez écrire des instructions dans un fichier texte. Celles-ci sont écrites dans un langage de programmation (ou langage formel) comme Ada, compréhensible par les humains.
Pour traduire un texte écrit en langage de programmation en un programme écrit en binaire, vous devrez utiliser un logiciel appelé compilateur.
Partie 1 : Premiers pas avec Ada 14/312
Les logiciels nécessaires
Nous allons au cours de ce chapitre, télécharger et installer les logiciels nécessaires à l'utilisation d'Ada.
Comment ça LES logiciels ? Il n'y a pas un seul logiciel Ada ?
Eh bien non. Comme tout langage, Ada a besoin de deux types de logiciels : un éditeur de texte avancé (appelé IDE) et un compilateur. Nous utiliserons l'IDE appelé Adagide (même si le logiciel GPS pourra être utilisé) et le compilateur GNAT. Après quoi, nous pourrons découvrir (enfin) le joyeux monde de la programmation.
IDE et compilateur : kesako ? Le compilateur
Nous avons dors et déjà parlé du compilateur : il s'agit d'un programme qui va traduire notre langage Ada en un vrai programme utilisable par l'ordinateur. Le compilateur est aussi chargé de vérifier la syntaxe de notre code : est-il bien écrit ? Sans fautes d'orthographe ou de grammaire ? Il existe plusieurs compilateurs en Ada, mais rassurez-vous, quel que soit celui que vous choisirez, les règles sur le langage Ada seront toujours les mêmes car Ada est un langage normé (il bénéficie d'une norme internationale assurant que tous les compilateurs Ada respecteront les mêmes règles). Il existe plusieurs compilateurs Ada (vous en trouverez une liste à l'adresse suivante), mais la plupart sont des programmes payants et propriétaires (donc non libre).
Payant ! C'était pas prévu au contrat ça !
Rassurez-vous, nous allons plutôt opter pour un compilateur libre et gratuit. Ce compilateur s'appelle GNAT et est développé par la société Adacore. Il a longtemps été payant mais une version gratuite existe désormais (GNAT GPL).
L'IDE ou EDI
Cela dit, le compilateur n'est en définitive qu'un «traducteur». Il ne créera pas de programme à votre place, c'est-à-vous d'écrire les instructions dans des fichiers textes. Pour cela, vous pouvez écrire vos documents sous l'éditeur de texte de votre ordinateur (notepad sous Windows par exemple), ou utiliser un éditeur de texte un peu plus avancé comme Notepad++ qui colorera votre texte intelligemment en reconnaissant le langage dans lequel vous programmerez (on appelle ça la coloration syntaxique).
Mais le plus simple, c'est d'utiliser un Environnement de Développement Intégré, EDI en français ou IDE en anglais. Pourquoi ? Eh bien parce que ce logiciel vous fournira un éditeur de texte avec coloration syntaxique et surtout vous permettra de compiler votre texte aisément, sans avoir besoin de chercher où se trouve le compilateur sur votre ordinateur. De plus, l'IDE se chargera de le paramétrer pour vous et vous fournira divers outils utiles à la programmation.
L'IDE que nous allons utilisé s'appelle Adagide et il est gratuit.
Télécharger et installer Adagide.
Disponible sous Windows uniquement
Téléchargement
Cliquez ici pour télécharger Adagide dans sa version 7.45 (dernière en date à l'heure où j'écris ces lignes). Puis cliquez sur
"adagide-7.45-setup.exe" pour lancer le téléchargement de l'installateur.
Installation
L'installation d'Adagide ne devrait pas vous poser de problèmes. Il vous suffit de suivre les différentes étapes des figures suivantes en cliquant sur «Suivant». Acceptez, tout d'abord, les termes de la licence et ensuite, à l'écran «Setup Type», choisissez «Typical».
Termes de la licence
Préférez l'installation Typical
Télécharger et installer GNAT.
Disponible sous Windows et Linux
Téléchargement
Pour télécharger le compilateur GNAT GPL, rendez-vous sur le site d'Adacore en cliquant ici.
Si vous êtes sous Windows, vérifiez que le système d'exploitation est bien «x-86 Windows» (à la ligne «Select your platform»), puis cliquez sur «GNAT_GPL» et sélectionnez «gnat-gpl-2013-i686-pc-mingw32-bin.exe». Enfin, tout en bas de la page, cliquez sur le bouton «Download selected files».
Pour les utilisateurs de Linux, le système d'exploitation devrait être «x86 - Linux» (ou «x86_64 - Linux» si votre processeur est en 64 bits). De la même manière que sous Windows, cliquez sur «GNAT_GPL» et sélectionnez «gnat-gpl-2013-i686-gnu-linux- libc2.3-bin.tar.gz». Pour finir, cliquez sur le bouton «Download selected files» en bas de page.
Installation
L'installation est un poil plus compliquée (même si ça ne casse pas trois pattes à un canard, comme dirait ma grand-mère ). Le fichier téléchargé s'appelle «AdaCore.tar» et ce n'est pas un programme d'installation, seulement un fichier compressé. Pour le décompresser, utilisez un logiciel comme Winrar ou 7zip. Sous Linux, vous pouvez procéder graphiquement ou par la console.
Dans le second cas, vous devrez taper la commande suivante : Code : Console
tar -xvzf gnat-gpl-2013-i686-gnu-linux-libc2.3-bin.tar.gz
Partie 1 : Premiers pas avec Ada 15/312
Sous Windows, vous obtiendrez ainsi le fameux fichier d'installation "gnat-gpl-2013-i686-pc-mingw32-bin.exe". Ouvrez-le et suivez les différentes étapes. Je vous conseille de sélectionner l'option «Install for all users», notamment si votre ordinateur dispose de plusieurs sessions, à moins que vous ne vouliez être le seul à pouvoir programmer en Ada.
Sous Linux, l'installation se fera via le fichier script appelé «doinstall». Celui-ci vous demandera si vous souhaitez installer GNAT et si oui, où. Vous n'aurez qu'à appuyer deux fois sur «Entrée» puis répondre «Yes» aux deux dernières questions en appuyant sur les touches Y ou y.
Télécharger et installer GPS
GPS est un autre IDE, mais développé par AdaCore. Il est un peu plus compliqué et j'avoue avoir eu du mal à l'installer sur mon PC Windows personnel (même s'il fonctionne sur mon PC Windows de bureau ou sous mon PC Ubuntu ). GPS est conçu pour gérer des projets importants composés de nombreux fichiers, mais Adagide a l'avantage d'être simple et performant, je le préfèrerai donc à GPS pour ce cours. Mais si vous souhaitez tout de même utilisez GPS, sachez qu'à cette étape du chapitre… il est déjà installé ! Cet IDE est en effet livré avec GNAT, vous pourrez donc le tester si la curiosité vous prend : il suffit d'aller dans le menu Démarrer > Programmes > GNAT > 2010 > GPS.
Si vous êtes sous Linux, vous ne pouvez disposer d'AdaGide. Vous serez donc amenés à utiliser l'IDE d'Adacore : GPS.
Si celui-ci n'apparaît pas dans vos applications, vous pourrez le lancer en tapant la commande «gnat-gps» dans votre console ou bien en l'ajoutant dans la liste de vos applications.
En résumé :
Vous devez disposer d'un IDE ou, à défaut, d'un éditeur de texte afin de rédiger le code source de votre programme.
Je vous conseille d'utiliser l'IDE Adagide pour sa simplicité. N'optez pour GPS que lorsque vous aurez acquis la maturité suffisante.
Vous devez disposer d'une version du compilateur GNAT.
Partie 1 : Premiers pas avec Ada 16/312
Notre premier programme en Ada
Bon, nous avons installé notre IDE, Adagide, notre compilateur, GNAT. Je sens que vous commencez à perdre patience. Nous allons immédiatement pouvoir nous atteler à notre premier programme en Ada. Il s'agira de créer un programme qui nous salue.
Bon, ce n'est sûrement pas folichon comme objectif, mais c'est un début. Voyons ici la démarche que nous allons suivre.
1. Tout d'abord, nous allons faire un petit tour d'horizon des logiciels Adagide et GPS. Je vous rassure, ce sera rapide.
2. Puis nous écrirons notre premier programme et nous le testerons.
3. Enfin, nous essaierons de décrypter notre premier programme
4. Avant de commencer le prochain chapitre je vous proposerai quelques petits suppléments et exercices pour vous entraîner.
Toujours pas découragé ? Alors au travail !
Découvrir son IDE en quelques secondes Soyons rapide avec Adagide
Pour pouvoir programmer, nous avons déjà expliqué que nous aurons besoin de l'IDE Adagide. Donc, lancez Adagide ! Vous voilà donc face à une fenêtre (voir la figure suivante) tout ce qu'il y a de plus… austère. Mais cela n'a que peu d'importance pour nous.
Votre
IDE : Adagide
Tout d'abord, nous allons créer un nouveau document. Pour cela, cliquez sur File > New ou sur l'icône «Nouveau» indiqué sur la figure précédente. Vous pourrez également à l'avenir ouvrir un document existant en cliquant sur File > Open ou sur l'icône
«Ouvrir».
Pour l'heure, nous allons enregistrer notre document. Cliquez sur File > Save as ou sur l'icône «enregistrer». Je vous conseille de créer un répertoire que nous nommerons «Hello», et dans ce répertoire nous allons enregistrer notre document (appelons-le également «Hello»). Vous remarquerez que l'extension proposée est adb. Notre code en Ada portera le nom de Hello.adb ; par la suite nous verrons à quoi peut servir l'extension ads qui est également proposée.
Bien entendu, il est possible d'écrire dans la fenêtre principale, la taille du texte pouvant être modifiée en cliquant sur le bouton
«taille». En revanche, il est impossible d'écrire dans la partie basse de la fenêtre, celle-ci étant réservée au compilateur. C'est ici que le compilateur affichera les informations qui vous seront nécessaires : échec de la compilation, réussite de la compilation, lignes inutiles …
Pour les utilisateurs de GPS (plus long)
Le logiciel GPS est un peu plus compliqué que Adagide. Il est toutefois mieux adapté à de gros projets, ce qui explique qu'il soit plus complexe et donc moins adapté pour ce cours. Lorsque vous lancez GPS, une fenêtre devrait vous demander ce que vous souhaitez faire.
Fenêtre
d'accueil du logiciel GPS
Pour l'heure, choisissez «Create new project with wizard» et cliquez sur «OK». Choisissez l'option «Single project» puis cliquez sur «Forward». Choisissez un nom pour votre projet (j'ai choisi «HelloWorld») et précisez un répertoire où l'enregistrer (je vous conseille de créer un répertoire spécifique par projet). Cliquez ensuite sur «Apply» sans renseigner les autres informations.
Vous devriez arriver à l'écran suivant :
Fenêtre de
projet avec GPS
Partie 1 : Premiers pas avec Ada 17/312
La fenêtre est découpée en quatre zones. La première ne nous intéresse pas pour l'instant. La seconde, juste en dessous, affichera les fichiers et programmes de votre projet. Pour l'heure vous n'aurez qu'un seul fichier donc cela ne comportera pas d'intérêt pour les premiers cours. Son utilité se révèlera à partir de la Partie III. La troisième zone de la fenêtre est la zone principale, celle où vous rédigerez votre programme. Enfin, la quatrième zone est celle réservée au compilateur et à la console.
Vous comprendrez son utilité bientôt.
Commençons donc par créer un nouveau fichier en cliquant sur l'icône «Nouveau» ou sur File > New. Sauvegardez tout de suite votre fichier en cliquant soit sur l'icône «Enregistrer» soit sur File > Save As. Votre fichier devra s'appeler «Hello.adb» (même si vous n'avez pas besoin d'écrire l'extension). Comme je vous le disais plus haut, il existe également un fichier .ads que nous verrons plus tard et que le logiciel GPS gère aussi. Pour ouvrir un document, vous pourrez utiliser l'icône «Ouvrir» ou sur File >
Open.
Voila pour l'essentiel, toutefois, je vais vous demander d'effectuer deux petites manipulations avant d'aller plus loin afin d'ajouter deux icônes importantes. Cliquez sur le menu Build > Settings > Targets. Une fenêtre devrait s'ouvrir (voir la figure suivante).
Fenêtre de configuration
À gauche, dans la section Project, cliquez sur Build <current file> et cochez la case In the toolbar. Puis, dans la section Run, cliquez sur Custom et cochez la case In the toolbar. Enfin, cliquez sur le bouton Apply. Deux icônes devraient s'ajouter, comme celles des figures suivantes (retenez-les bien).
Construire Exécuter
Notre premier programme Un petit copier-coller !
Maintenant que nous avons rapidement pris connaissance du logiciel, il est temps de nous lancer corps et âme dans la création de notre magnifique programme «Hello» ! Nous allons pour cela effectuer une opération de haute voltige : un copier-coller ! Voici le code d'un programme. Ne cherchez pas à comprendre pour l'instant, je vous expliquerai par la suite. Pour l'heure, sélectionnez le texte, copiez-le et collez-le dans votre fichier Hello.adb sans poser de questions.
Code : Ada
with ada.text_io ; use ada.text_io ; procedure Hello is
--partie réservée aux déclarations begin
put("Salut tout le monde !") ; --on affiche un message end Hello ;
Vous remarquerez que certains mots sont automatiquement colorés, je vous en ai déjà parlé, c'est la coloration syntaxique. Elle permet de faire ressortir certains mot-clés (Adagide colore par défaut en bleu les mots réservés au langage Ada) ou certains types de texte.
Avant d'aller plus loin, si vous êtes sous Adagide (GPS effectuera cette manœuvre tout seul le moment venu), il serait bon de cliquer sur l'icône «Reformat», il est simple à trouver, c'est celui avec un grand R dessiné dessus. Cela va mettre votre code en forme : la ligne entre is et begin et la ligne entre begin et end vont être «avancées» à l'aide d'une tabulation (trois espaces sous adagide). On appelle ça l'indentation. Ca n'a l'air de rien mais c'est très important car à l'avenir votre code pourra s'étendre sur plusieurs pages, il est donc important qu'il soit le plus lisible possible. Lorsque l'on rédige un roman, on crée des paragraphes, des chapitres… en programmation on indente son texte.
Compiler, créer… lancer !
Maintenant que votre texte est écrit et mis en forme, il est temps de le faire fonctionner. Nous allons donc utiliser le compilateur.
Pour cela, rien de plus simple, cliquez sur l'icône «Compiler» (ou appuyer sur F2 avec Adagide, ou encore Compile > Compile File). Le compilateur vérifiera la syntaxe de votre code. S'il n'y a pas d'erreur (et il ne devrait pas y en avoir), le compilateur devrait vous indiquer (dans la fenêtre du bas) «Completed successfully».
Mais à ce stade, votre programme n'existe pas encore, vous devez construire l'exécutable. Pour cela cliquez sur l'icône
«construire» (ou appuyez sur F3 avec Adagide ou cliquez sur Compile > Build).
Pour les utilisateurs de GPS, les manipulations étant un peu longues, je vous conseille d'utiliser les icônes (c'est bien pour cela que je vous ai fait faire une petite manipulation préliminaire). Lorsque vous cliquerez sur l'icône «Construire», une fenêtre peut s'ouvrir. Ne vous souciez pas des paramètres et cliquez sur OK.
Votre fichier exécutable est désormais créé. Vous pouvez soit aller le chercher dans le répertoire Hello que vous avez créé tout à l'heure, soit cliquer sur l'icône «Exécuter» (ou appuyer sur F4 avec Adagide ou cliquer sur Run > Execute). Sous GPS, une fenêtre s'ouvrira. Ne cochez aucune case et, si la barre de texte est vide, écrivez-y le nom de votre programme : Hello (sans extension !). Puis cliquez sur OK.
Avec Adagide, vous devriez ainsi obtenir une magnifique fenêtre noire vous indiquant : Code : Console
Salut tout le monde !
(Sous GPS, ces actions apparaîtront dans la fenêtre du compilateur, c'est-à-dire la quatrième zone de la fenêtre) Euh… comment dire…, c'est tout ? J'ai lu tous ces chapitres pour voir ça ?!
Ne perdez pas patience. Le chemin sera long avant que vous ne puissiez créer un programme digne d'intérêt. Prenons le temps de décortiquer ce que nous avons copié pour mieux comprendre.
Mon dieu, qu'ai-je fait ?
Si nous jetons un œil à notre code nous pouvons nous rendre compte qu'il peut se décomposer en deux parties majeures : une sorte de titre (avec with et use) et un gros paragraphe (commençant par le mot procedure).
Partie 1 : Premiers pas avec Ada 18/312
Organisation de votre code
Le corps du programme : la procédure Hello
Le titre étant un peu compliqué à expliquer, nous allons commencer par nous intéresser au «gros paragraphe» : la procédure appelée Hello. Elle peut se décomposer elle-même en deux parties comme sur la figure précédente.
Les trois bornes de la procédure
Pour l'instant, disons que le terme de «procédure» est un synonyme de «programme». Notre paragraphe commence donc par l'introduction suivante : PROCEDURE Hello IS. Cette phrase permet de donner un nom à notre procédure et indique le début du texte la concernant. Remarquez que les mots procedure et is sont colorés en bleu : ce sont des mots réservés par le langage Ada, ils ont donc un sens très précis et ne peuvent être utilisés n'importe comment.
Deuxième «borne» de notre procédure : le terme begin. C'est lui aussi un mot réservé. Il indique au compilateur le début des instructions que l'ordinateur devra exécuter.
Troisième «borne» : le mot end, ou plus exactement la phrase : «END Hello ;». Cette phrase indique au compilateur la fin de la procédure Hello. À noter que contrairement aux deux bornes précédentes, cette phrase se termine par un point-virgule. Si vous oubliez de l'écrire, le compilateur vous avertira : missing ";" ! Notez que les points virgule indiquent au compilateur la fin d'une instruction : ici, c'est la fin de votre procédure.
La partie Déclaration
Les trois bornes vues précédemment délimitent deux zones. La première, celle comprise entre is et begin, est réservée aux déclarations. Nous verrons dans les prochains chapitres de quoi il retourne. Sachez pour l'instant que votre programme peut avoir besoin de mémoire supplémentaire pour fonctionner (et nous aurons très vite besoin de davantage de mémoire) et que c'est dans cette partie que s'effectueront les demandes de réquisition de mémoire. Pour l'heure, il n'y a rien.
Comment ça il n'y a rien ? Il y a bien quelque chose d'écrit : «--partie réservée aux déclarations»
Eh bien non. Pour le compilateur, il n'y a rien ! Cette ligne verte commence par deux tirets. Cela signifie qu'il s'agit d'un commentaire, c'est-à-dire d'un texte qui ne sera pas pris en compte par le compilateur. Quel intérêt d'écrire du texte s'il n'est pas pris en compte par le compilateur ? Eh bien cela permet d'apporter des annotations à votre code. Si vous relisez un code écrit par quelqu'un d'autre ou par vous même il y a longtemps, vous risquez d'avoir du mal à le comprendre. Les commentaires sont donc là pour expliquer ce que fait le programme, à quoi servent telle ou telle ligne, etc. Un bon code est déjà un code bien commenté (et bien indenté également).
La partie Action et notre première instruction
Puis, après le BEGIN, vient la partie la plus intéressante, celle où l'on indique au programme ce qu'il doit faire, autrement dit, c'est là que nous écrirons les différentes instructions.
L'instruction citée ici est : «Put("Salut tout le monde!") ;». C'est assez simple à comprendre : l'instruction Put() indique à l'ordinateur qu'il doit afficher quelque chose. Et entre les parenthèses, on indique ce qu'il faut afficher. Il est possible d'afficher un nombre (par exemple, «Put(13) ;» affichera le nombre 13) comme du texte, mais le texte doit être écrit entre guillemets.
Remarquez là encore que l'instruction se termine par un point-virgule. D'ailleurs, toutes les instructions devront se terminer par un point virgule, à quelques exceptions près (souvenez-vous de IS et BEGIN). Le texte qui suit est bien entendu un commentaire et tout ce qui suit les double-tirets ne sera pas pris en compte par le compilateur.
Il est bien sûr possible d'afficher autre chose que "salut tout le monde !" ou d'effectuer d'autres actions. Toutefois, lorsque toutes vos actions ont été écrites, n'oubliez pas d'indiquer au compilateur que vous avez atteint la fin du programme en utilisant le mot-clé END.
Les Packages avec With et Use
Le mot-clé WITHRevenons maintenant au titre. Pourquoi cet intitulé ? Et d'ailleurs pourquoi l'écrire deux fois ? Je vous propose de le supprimer pour mieux comprendre. Compiler à nouveau votre code.
Argh ! ! Ça ne marche plus ! J'ai pleins de messages rouge ! Tout est fichu !
En effet, le code n'est plus correct et ce n'est pas la peine d'essayer de reconstruire notre programme. Mais lisons tout d'abord les avertissements du compilateur : «Put» is undefined.
Cela signifie tout simplement que le compilateur ne connaît plus l'instruction Put() ! En effet, le compilateur ne connaît que très peu de mots et d'instructions : les mots réservés et puis, c'est presque tout. Pour aller plus loin, il a besoin de fichiers qui contiennent d'avantage d'instructions comme l'instruction Put() par exemple, qui se situe dans un fichier appelé Ada.Text_IO.
Ces fichiers portent le nom de package en Ada (paquetages en français). Dans d'autres langages, on parlerait de librairies.
Nous reviendrons plus en détail sur les packages durant la troisième et la quatrième partie de ce tutoriel. Donc si cette sous-partie vous semble compliquée, rassurez-vous, je vous indiquerai toujours les packages à écrire en début de code.
Le compilateur nous dit également : possible missing «WITH Ada.Text_IO ; USE Ada.Text_IO ;».
Traduction : ce serait bien de remettre les lignes que vous avez supprimé tout à l'heure ! Écoutons-le mais ne réécrivons que la première ligne (au tout début) :
Code : Ada
WITH Ada.Text_IO ;
Le mot-clé USE
Réessayons de compiler.
J'ai un nouveau problème. Le compilateur m'indique : «Put» is not visible, plus plein d'autres insultes incompréhensibles. Apparemment, il connait mon instruction Put() mais il n'arrive plus à la voir ?!
Exactement. Et les lignes qui suivent indiquent que dans le package ada.Text_IO, il y a plusieurs références à l'instruction Put().
En fait, il est possible après l'instruction with d'écrire de nombreux packages, autant que vous voulez même (nous verrons un exemple juste après). Mais il peut exister (et il existe) plusieurs instructions portant le nom Put(), du coup le compilateur ne sait pas d'où vient cette instruction. De laquelle s'agit-il ? Une solution est de remplacer Put() par Ada.Text_IO.Put() ! C'est compliqué, c'est long à écrire et nous aurons tout le loisir de comprendre tout cela plus tard. Donc une façon de s'épargner ces difficultés, c'est d'écrire notre instruction Use au tout début, juste après l'instruction with.
Ces deux lignes (appelées Context Clause en Ada ou Clauses de contexte en Français) sont donc indispensables et vous serez souvent amenés à réécrire les mêmes (vous bénirez bientôt l'inventeur du copier-coller). Ne croyez pas que cette lourdeur soit spécifique à Ada. Tout langage a besoin de packages ou librairies annexes, tout n'est pas prédéfini et heureusement pour nous : c'est ce que l'on appelle la modularité. Au final, voici la structure de notre programme et de tout programme Ada (voir la figure)
La structure du programme
Avec plusieurs packages
J'ai essayé de bidouiller le code pour qu'il affiche 13 comme tu le disais dans un exemple. Mais le compilateur râle encore : warning : no entities of «Text_Io» are referenced, no candidate match the actuals :… Bref, rien ne va plus.
