Apprendre à programmer avec Ada

352 Pages·2012·8.61 MB·French

Apprendre à
programmer avec Ada
Par Kaji9
www.siteduzero.com
Licence Creative Commons 4 2.0
Dernière mise à jour le 21/11/2012
2/353
Sommaire
Sommaire ........................................................................................................................................... 2
Lire aussi ............................................................................................................................................ 5
Apprendre à programmer avec Ada ................................................................................................... 7
Partie 1 : Premiers pas avec Ada ........................................................................................................ 8
Programmation, algorithmique et Ada ? ............................................................................................................................ 8
Qu'est-ce qu'un programme ? ..................................................................................................................................................................................... 8
Qu'appelle-t-on programme ? ..................................................................................................................................................................................... 8
Alors qu'allons-nous faire ? ....................................................................................................................................................................................... 11
Comment réaliser un programme ? .......................................................................................................................................................................... 12
Pourquoi Ada et pas autre chose ? ........................................................................................................................................................................... 13
Algorithmique ............................................................................................................................................................................................................ 13
Pourquoi Ada ? .......................................................................................................................................................................................................... 15
Les logiciels nécessaires ................................................................................................................................................ 16
IDE et compilateur : kesako ? ................................................................................................................................................................................... 16
Le compilateur ........................................................................................................................................................................................................... 16
L'IDE ou EDI .............................................................................................................................................................................................................. 16
Télécharger et installer Adagide. ............................................................................................................................................................................... 16
Téléchargement ........................................................................................................................................................................................................ 16
Installation ................................................................................................................................................................................................................. 16
Télécharger et installer GNAT. .................................................................................................................................................................................. 17
Téléchargement ........................................................................................................................................................................................................ 17
Installation ................................................................................................................................................................................................................. 17
Télécharger et installer GPS ..................................................................................................................................................................................... 17
Notre premier programme en Ada ................................................................................................................................... 18
Découvrir son IDE en quelques secondes ................................................................................................................................................................ 19
Soyons rapide avec Adagide ..................................................................................................................................................................................... 19
Pour les utilisateurs de GPS (plus long) ................................................................................................................................................................... 20
Notre premier programme ......................................................................................................................................................................................... 22
Un petit copier-coller ! ............................................................................................................................................................................................... 22
Compiler, créer ... lancer ! ......................................................................................................................................................................................... 23
Mon dieu, qu'ai-je fait ? ............................................................................................................................................................................................. 23
Le corps du programme : la procédure Hello ............................................................................................................................................................ 24
Les Packages avec With et Use ............................................................................................................................................................................... 25
Une dernière remarque qui a son importance ........................................................................................................................................................... 26
Vous en voulez encore ? ........................................................................................................................................................................................... 26
Exercice 1 .................................................................................................................................................................................................................. 26
Exercice 2 .................................................................................................................................................................................................................. 27
Exercice 3 .................................................................................................................................................................................................................. 28
Partie 2 : Ada, notions essentielles ................................................................................................... 29
Variables I : Typage et affectation ................................................................................................................................... 29
Déclaration de variables ............................................................................................................................................................................................ 29
Différents types ......................................................................................................................................................................................................... 30
Les types Integer et Natural ...................................................................................................................................................................................... 30
Le type Float .............................................................................................................................................................................................................. 31
Le type Character ...................................................................................................................................................................................................... 32
Affectation ................................................................................................................................................................................................................. 33
Affectation par le programmeur (ou le programme) .................................................................................................................................................. 33
Affectation par l'utilisateur ......................................................................................................................................................................................... 33
L'instruction Skip_line ................................................................................................................................................................................................ 34
Constantes et attributs .............................................................................................................................................................................................. 35
Constantes ................................................................................................................................................................................................................ 35
Attributs ..................................................................................................................................................................................................................... 36
Variables II : Opérations .................................................................................................................................................. 38
Opérations sur les Integer et les Natural ................................................................................................................................................................... 38
Opérations sur les float ............................................................................................................................................................................................. 39
Opérations sur les character ..................................................................................................................................................................................... 39
Exercices ................................................................................................................................................................................................................... 40
Exercice 1 .................................................................................................................................................................................................................. 40
Exercice 2 .................................................................................................................................................................................................................. 41
Exercice 3 .................................................................................................................................................................................................................. 41
Exercice 4 .................................................................................................................................................................................................................. 42
Les conditions I ............................................................................................................................................................... 43
Conditions simples avec IF ....................................................................................................................................................................................... 44
Un début en douceur ................................................................................................................................................................................................. 44
Une première alternative ........................................................................................................................................................................................... 45
Conditions multiples avec IF ..................................................................................................................................................................................... 45
Conditions multiples avec CASE ............................................................................................................................................................................... 47
Les opérateurs de comparaison ................................................................................................................................................................................ 47
Les conditions II : les booléens ....................................................................................................................................... 49
Introduction aux booléens ......................................................................................................................................................................................... 50
Un bref historique ...................................................................................................................................................................................................... 50
Qu'est-ce qu'un booléen ? ......................................................................................................................................................................................... 50
Les opérateurs booléen ............................................................................................................................................................................................. 51
La négation avec Not ................................................................................................................................................................................................ 51
www.siteduzero.com
Sommaire 3/353
Les opérations Or et And ........................................................................................................................................................................................... 52
L'instruction or ........................................................................................................................................................................................................... 52
L'instruction and ........................................................................................................................................................................................................ 52
L'opération xor (optionnel) ......................................................................................................................................................................................... 53
Bilan de notre programme ......................................................................................................................................................................................... 53
Priorités booléennes et ordre de test (Supplément) .................................................................................................................................................. 54
Priorités avec les booléens ....................................................................................................................................................................................... 54
Ordre de test ............................................................................................................................................................................................................. 55
Les boucles ..................................................................................................................................................................... 57
La boucle Loop simple .............................................................................................................................................................................................. 57
La boucle While ......................................................................................................................................................................................................... 59
La boucle For ............................................................................................................................................................................................................ 59
Les antiquités : l'instruction goto ............................................................................................................................................................................... 60
Boucles imbriquées ................................................................................................................................................................................................... 61
Méthode avec une seule boucle (plutôt mathématique) ........................................................................................................................................... 61
Méthode avec deux boucles (plus naturelle) ............................................................................................................................................................. 62
Exercices ................................................................................................................................................................................................................... 63
Exercice 1 .................................................................................................................................................................................................................. 63
Exercice 2 .................................................................................................................................................................................................................. 63
Exercice 3 .................................................................................................................................................................................................................. 64
Exercice 4 .................................................................................................................................................................................................................. 64
Exercice 5 .................................................................................................................................................................................................................. 64
Exercice 6 .................................................................................................................................................................................................................. 64
Procédures et fonctions I ................................................................................................................................................ 65
Les procédures .......................................................................................................................................................................................................... 65
Procédure sans paramètre ........................................................................................................................................................................................ 65
Procédure avec un paramètre (ou argument) ........................................................................................................................................................... 67
Procédure avec plusieurs paramètres (ou arguments) ............................................................................................................................................. 69
Les fonctions ............................................................................................................................................................................................................. 70
Une bête fonction ...................................................................................................................................................................................................... 70
Une fonction un peu moins bête (optionnel) ............................................................................................................................................................. 71
Bilan .......................................................................................................................................................................................................................... 73
Prédéfinir ses paramètres ......................................................................................................................................................................................... 75
In, Out, In Out ............................................................................................................................................................................................................ 77
Mode in ...................................................................................................................................................................................................................... 77
Mode out ................................................................................................................................................................................................................... 77
Mode in out ................................................................................................................................................................................................................ 77
[TP1] le craps .................................................................................................................................................................. 79
Les règles du craps ................................................................................................................................................................................................... 79
Cahier des charges ................................................................................................................................................................................................... 79
Simuler le hasard (ou presque) ................................................................................................................................................................................. 80
Un plan de bataille .................................................................................................................................................................................................... 81
Une solution .............................................................................................................................................................................................................. 82
Partie 3 : Ada, les types composites ................................................................................................. 84
Les tableaux .................................................................................................................................................................... 85
Les types composites, c'est quoi ? ............................................................................................................................................................................ 85
Tableaux unidimensionels ......................................................................................................................................................................................... 86
Problème ................................................................................................................................................................................................................... 86
Création d'un tableau en Ada .................................................................................................................................................................................... 87
Attributs pour les tableaux ......................................................................................................................................................................................... 90
Tableaux multidimensionels ...................................................................................................................................................................................... 91
Tableaux bidimensionnels ......................................................................................................................................................................................... 91
Tableaux tridimensionnels et plus ............................................................................................................................................................................. 92
Et mes attributs ? ...................................................................................................................................................................................................... 94
Et mes agrégats ? ..................................................................................................................................................................................................... 94
Des tableaux un peu moins contraints ...................................................................................................................................................................... 95
Un type non-contraint ou presque ............................................................................................................................................................................. 95
Affectation par tranche .............................................................................................................................................................................................. 95
Déclarer un tableau en cours de programme ............................................................................................................................................................ 96
Quelques exercices ................................................................................................................................................................................................... 97
Exercice 1 .................................................................................................................................................................................................................. 97
Exercice 2 .................................................................................................................................................................................................................. 98
Exercice 3 ................................................................................................................................................................................................................ 100
Les chaînes de caractères ............................................................................................................................................ 103
Présentation des Chaînes de Caractères ............................................................................................................................................................... 103
Déclaration et affectation d'un string ....................................................................................................................................................................... 103
Quelques opérations sur les strings ........................................................................................................................................................................ 104
Accès à une valeur .................................................................................................................................................................................................. 104
Accès à plusieurs valeurs ....................................................................................................................................................................................... 104
Modifier la casse ..................................................................................................................................................................................................... 105
Concaténation ......................................................................................................................................................................................................... 105
Transformer une variable en string et inversement ................................................................................................................................................. 106
Comparaison ........................................................................................................................................................................................................... 107
Saisie au clavier ...................................................................................................................................................................................................... 107
Chaînes de caractères non contraintes ................................................................................................................................................................... 108
Déclarer des strings illimités ! ................................................................................................................................................................................. 108
Opérations sur les unbounded_string ..................................................................................................................................................................... 108
La programmation modulaire I : les packages .............................................................................................................. 111
Les fichiers nécessaires .......................................................................................................................................................................................... 111
Notre première procédure... empaquetée ............................................................................................................................................................... 112
Compléter notre package (exercices) ...................................................................................................................................................................... 115
Procédures d'affichage ............................................................................................................................................................................................ 115
www.siteduzero.com
Sommaire 4/353
Procédures de création ........................................................................................................................................................................................... 116
Fonctions de tri ........................................................................................................................................................................................................ 116
Opérations élémentaires ......................................................................................................................................................................................... 116
Compléter notre package (solutions) ....................................................................................................................................................................... 117
Vecteurs et calcul vectoriel (optionnel) .................................................................................................................................................................... 121
Qu'est-ce exactement qu'un T_Vecteur ? ............................................................................................................................................................... 121
Calcul vectoriel ........................................................................................................................................................................................................ 121
Les fichiers .................................................................................................................................................................... 122
Ouvrir / Fermer un fichier texte ................................................................................................................................................................................ 123
Package nécessaire ................................................................................................................................................................................................ 123
Le type de l'objet ..................................................................................................................................................................................................... 123
Fermer un fichier ..................................................................................................................................................................................................... 123
Ouvrir un fichier ....................................................................................................................................................................................................... 124
Le paramètre Mode ................................................................................................................................................................................................. 126
Lecture seule ........................................................................................................................................................................................................... 126
Ecriture seule .......................................................................................................................................................................................................... 126
Ajout ........................................................................................................................................................................................................................ 126
Opérations sur les fichiers textes ............................................................................................................................................................................ 127
Mode lecture seule : In_File .................................................................................................................................................................................... 127
Mode écriture : Out_File / Append_File ................................................................................................................................................................... 130
Autres opérations .................................................................................................................................................................................................... 130
Les fichiers binaires séquentiels ............................................................................................................................................................................. 131
Les fichiers binaires directs ..................................................................................................................................................................................... 133
Quelques exercices ................................................................................................................................................................................................. 134
Exercice 1 ................................................................................................................................................................................................................ 134
Exercice 2 ................................................................................................................................................................................................................ 135
Exercice 3 ................................................................................................................................................................................................................ 136
Créer vos propres objets ............................................................................................................................................... 138
Créer à partir de types prédéfinis ............................................................................................................................................................................ 139
Sous-type comme intervalle .................................................................................................................................................................................... 139
Types modulaires .................................................................................................................................................................................................... 139
Enumérer les valeurs d'un type ............................................................................................................................................................................... 140
Les types structurés ................................................................................................................................................................................................ 141
Déclarer un type "construit" ..................................................................................................................................................................................... 141
Ordre des déclarations ............................................................................................................................................................................................ 143
Déclarer et modifier un objet de type structuré ....................................................................................................................................................... 144
22 ! Rev'là les tableaux ! ......................................................................................................................................................................................... 145
Les types structurés : polymorphes et mutants ! ..................................................................................................................................................... 147
Les types structurés polymorphes ........................................................................................................................................................................... 147
Les types structurés mutants .................................................................................................................................................................................. 149
[TP2] logiciel de gestion de bibliothèque ...................................................................................................................... 152
Cahier des charges ................................................................................................................................................................................................. 153
Quelles données pour quels types de données ? ................................................................................................................................................... 153
Quelle architecture pour les fichiers ........................................................................................................................................................................ 154
Quelles fonctionnalités pour quelles fonctions et procédures ? .............................................................................................................................. 154
Architecture du code source ................................................................................................................................................................................... 155
Conception du programme (suivez le guide) .......................................................................................................................................................... 155
Création des types .................................................................................................................................................................................................. 155
Affichage d'une œuvre ............................................................................................................................................................................................ 156
Saisie d'une oeuvre ................................................................................................................................................................................................. 156
Gestion des fichiers ................................................................................................................................................................................................. 157
Les commandes ...................................................................................................................................................................................................... 158
Solutions possibles ................................................................................................................................................................................................. 158
Les pointeurs I : allocation dynamique .......................................................................................................................... 167
Mémoire, variable et pointeur .................................................................................................................................................................................. 168
Le type access ........................................................................................................................................................................................................ 171
Déclarer un pointeur ................................................................................................................................................................................................ 171
Que contient mon pointeur ? ................................................................................................................................................................................... 172
Comment accéder aux données ? .......................................................................................................................................................................... 173
Opérations sur les pointeurs ................................................................................................................................................................................... 173
Une erreur à éviter .................................................................................................................................................................................................. 175
Libération de la mémoire ......................................................................................................................................................................................... 175
Un programme (un peu) gourmand ......................................................................................................................................................................... 175
Un problème de mémoire ........................................................................................................................................................................................ 176
Résolution du problème .......................................................................................................................................................................................... 178
Exercices ................................................................................................................................................................................................................. 179
Exercice 1 ................................................................................................................................................................................................................ 179
Exercice 2 ................................................................................................................................................................................................................ 180
Les pointeurs II .............................................................................................................................................................. 182
Cas général ............................................................................................................................................................................................................. 182
Pointeurs généralisés : pointer sur une variable ..................................................................................................................................................... 182
Pointeur sur une constante et pointeur constant ..................................................................................................................................................... 183
Pointeur sur pointeur ............................................................................................................................................................................................... 184
Pointeur comme paramètre ..................................................................................................................................................................................... 185
Pointeur sur un programme (optionnel) .................................................................................................................................................................. 186
Un exemple simple .................................................................................................................................................................................................. 186
Un exemple de la vie courante ................................................................................................................................................................................ 188
Un exemple très ... mathématique .......................................................................................................................................................................... 188
Exercices ................................................................................................................................................................................................................. 191
Exercice 1 ................................................................................................................................................................................................................ 191
Exercice 2 ................................................................................................................................................................................................................ 192
Exercice 3 ................................................................................................................................................................................................................ 193
www.siteduzero.com
Sommaire 5/353
Exercice 4 ................................................................................................................................................................................................................ 194
Exercice 5 (Niveau Scientifique) ............................................................................................................................................................................. 194
Fonctions et procédures II : la récursivité ..................................................................................................................... 196
Une première définition ........................................................................................................................................................................................... 197
Exemple d'algorithme récursif ................................................................................................................................................................................. 198
Un premier exemple de fonction récursive .............................................................................................................................................................. 199
Énoncé .................................................................................................................................................................................................................... 199
Indications ............................................................................................................................................................................................................... 199
Une solution possible .............................................................................................................................................................................................. 201
Algorithme de recherche par dichotomie ................................................................................................................................................................ 201
Principe ................................................................................................................................................................................................................... 201
Mise en œuvre ........................................................................................................................................................................................................ 203
Solution ................................................................................................................................................................................................................... 203
Quelques exercices ................................................................................................................................................................................................. 204
Exercice 1 ................................................................................................................................................................................................................ 204
Exercice 2 ................................................................................................................................................................................................................ 205
Exercice 3 ................................................................................................................................................................................................................ 206
Exercice 4 ................................................................................................................................................................................................................ 207
Les Types Abstraits de Données : listes, files, piles ... ................................................................................................. 207
Qu'est-ce qu'un Type Abstrait de Données ? .......................................................................................................................................................... 208
Un premier cas ........................................................................................................................................................................................................ 208
Autres cas ............................................................................................................................................................................................................... 209
Primitives ................................................................................................................................................................................................................. 212
Les piles .................................................................................................................................................................................................................. 213
Création du type T_Pile ........................................................................................................................................................................................... 213
Création des primitives ............................................................................................................................................................................................ 214
Jouons avec le package P_Pile .............................................................................................................................................................................. 217
Les files ................................................................................................................................................................................................................... 218
Implémentation ........................................................................................................................................................................................................ 218
Amusons-nous encore ............................................................................................................................................................................................ 220
Les listes chaînées .................................................................................................................................................................................................. 221
Quelques rappels .................................................................................................................................................................................................... 221
Le package Ada.Containers.Doubly_Linked_Lists .................................................................................................................................................. 222
Le package Ada.Containers.Vectors ....................................................................................................................................................................... 226
[TP3] le jeu du serpent .................................................................................................................................................. 228
Cahier des charges ................................................................................................................................................................................................. 229
Fonctionnalités ........................................................................................................................................................................................................ 229
Organisation des types et variables ........................................................................................................................................................................ 229
Un package bien utile .............................................................................................................................................................................................. 230
Le package NT_Console ......................................................................................................................................................................................... 230
Le contenu en détail ................................................................................................................................................................................................ 241
... et encore un autre ! ............................................................................................................................................................................................. 243
Quelques indications ............................................................................................................................................................................................... 244
Jouer en temps réel ................................................................................................................................................................................................ 244
Comment afficher un serpent et une zone de jeu en couleur ? .............................................................................................................................. 245
Par où commencer ? ............................................................................................................................................................................................... 246
Une solution possible .............................................................................................................................................................................................. 246
Partie 4 : Ada : Notions avancées en Programmation Orientée Objet ............................................ 254
Algorithmique : tri et complexité .................................................................................................................................... 255
Algorithmes de tri lents ............................................................................................................................................................................................ 255
Tri par sélection (ou par extraction) ......................................................................................................................................................................... 256
Tri par insertion ....................................................................................................................................................................................................... 257
Tri à bulles (ou par propagation) ............................................................................................................................................................................. 258
Algorithmes de tri plus rapides ................................................................................................................................................................................ 259
Tri rapide (ou Quick Sort) ........................................................................................................................................................................................ 259
Tri fusion (ou Merge Sort) ........................................................................................................................................................................................ 261
Tri par tas ................................................................................................................................................................................................................ 263
Théorie : complexité d'un algorithme ...................................................................................................................................................................... 269
Complexité .............................................................................................................................................................................................................. 269
L'écriture O .............................................................................................................................................................................................................. 269
Quelques fonctions mathématiques ........................................................................................................................................................................ 270
Mesures de complexité des algorithmes ................................................................................................................................................................. 272
Un algorithme pour mesurer la complexité ... des algorithmes ............................................................................................................................... 272
Traiter nos résultats ................................................................................................................................................................................................. 274
Variables III : Gestion bas niveau des données ............................................................................................................ 277
Représentation des nombres entiers ...................................................................................................................................................................... 277
Le code binaire ........................................................................................................................................................................................................ 277
Conversions entre décimal et binaire ...................................................................................................................................................................... 278
Retour sur le langage Ada ....................................................................................................................................................................................... 279
Représentation du texte .......................................................................................................................................................................................... 282
Représentation des nombres décimaux en virgule flottante ................................................................................................................................... 284
Représentation des float ......................................................................................................................................................................................... 284
Implications sur le langage Ada .............................................................................................................................................................................. 286
La programmation modulaire II : Encapsulation ........................................................................................................... 290
Qu'est-ce qu'un objet ? ............................................................................................................................................................................................ 290
Une première approche ........................................................................................................................................................................................... 290
Posons le vocabulaire ............................................................................................................................................................................................. 292
De nouvelles contraintes ......................................................................................................................................................................................... 293
Un package... privé ................................................................................................................................................................................................. 294
Partie publique / partie privée ................................................................................................................................................................................. 294
Visibilité ................................................................................................................................................................................................................... 296
Un package privé et limité ....................................................................................................................................................................................... 297
www.siteduzero.com
Lire aussi 6/353
Que faire avec un type private ? ............................................................................................................................................................................. 297
Restreindre encore notre type ................................................................................................................................................................................. 298
Exercices ................................................................................................................................................................................................................. 299
Exercice 1 ................................................................................................................................................................................................................ 300
Exercice 2 ................................................................................................................................................................................................................ 300
La programmation modulaire III : Généricité ................................................................................................................. 301
Généricité : les grandes lignes. ............................................................................................................................................................................... 302
Que veut-on faire ? .................................................................................................................................................................................................. 302
Plan de bataille ........................................................................................................................................................................................................ 302
Un dernier point de vocabulaire .............................................................................................................................................................................. 303
Créer et utiliser une méthode générique ................................................................................................................................................................. 304
Créer une méthode générique ................................................................................................................................................................................ 304
Utiliser une méthode générique .............................................................................................................................................................................. 305
Paramètres génériques de types simples et privés ................................................................................................................................................ 307
Types génériques simples ....................................................................................................................................................................................... 307
Types génériques privés ......................................................................................................................................................................................... 308
Paramètres génériques de types composites et programmes ................................................................................................................................ 308
Tableaux génériques ............................................................................................................................................................................................... 308
Pointeurs génériques .............................................................................................................................................................................................. 310
Paramètre de type programme : le cas d'un paramètre limited private ................................................................................................................... 310
Packages génériques .............................................................................................................................................................................................. 312
Exercice ................................................................................................................................................................................................................... 312
Solution ................................................................................................................................................................................................................... 313
Application ............................................................................................................................................................................................................... 315
La programmation modulaire IV : Héritage et dérivation .............................................................................................. 315
Pour bien commencer ............................................................................................................................................................................................. 316
Héritage : une première approche théorique ........................................................................................................................................................... 316
Héritage : une approche par l'exemple ................................................................................................................................................................... 317
Héritage ................................................................................................................................................................................................................... 318
Héritage de package simple .................................................................................................................................................................................... 318
Héritage avec des packages privés ........................................................................................................................................................................ 322
Héritage avec des packages génériques ................................................................................................................................................................ 324
Dérivation et types étiquetés ................................................................................................................................................................................... 325
Créer un type étiqueté ............................................................................................................................................................................................. 325
Et nos méthodes ? .................................................................................................................................................................................................. 326
Un autre avantage des classes ............................................................................................................................................................................... 329
Bilan : ...................................................................................................................................................................................................................... 330
La programmation modulaire V : Polymorphisme, abstraction et héritage multiple ..................................................... 330
Polymorphisme ....................................................................................................................................................................................................... 331
Méthodes polymorphes ........................................................................................................................................................................................... 331
Objets polymorphes ................................................................................................................................................................................................ 332
Abstraction .............................................................................................................................................................................................................. 336
Types abstraits ........................................................................................................................................................................................................ 336
Méthodes abstraites ................................................................................................................................................................................................ 337
Héritage multiple ..................................................................................................................................................................................................... 339
Comment Ada gère-t-il l'héritage multiple ? ............................................................................................................................................................ 339
Réaliser des interfaces Ada .................................................................................................................................................................................... 341
La programmation modulaire VI : Finalisation et types contrôlés ................................................................................. 345
Objectifs et prérequis .............................................................................................................................................................................................. 346
De quoi parle-t-on exactement ? ............................................................................................................................................................................. 346
Comment s'y prendre ? ........................................................................................................................................................................................... 347
Mise en œuvre ........................................................................................................................................................................................................ 348
Mise en place de nos types ..................................................................................................................................................................................... 348
Mise en place de nos méthodes ............................................................................................................................................................................. 348
www.siteduzero.com
Lire aussi 7/353
Apprendre à programmer avec Ada
Par Kaji9
Mise à jour : 21/11/2012
Difficulté : Intermédiaire Durée d'étude : 1 mois, 15 jours
3 818 visites depuis 7 jours, classé 43/797
Vous voudriez apprendre à programmer mais ne savez pas par où commencer ? Vous avez commencé à apprendre le C 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 compréhensible pour un novice.
Alors si vous êtes intéressé, nous allons pouvoir débuter de tutoriel.
Organisation du tutoriel :
Ce tutoriel est prévu pour être organisé en six 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 (ou traiteront) du langage Ada en lui-même et présenteront une difficulté progressive.
La partie V constituera une mise en pratique en vous proposant de créer des programmes fenêtrés avec GTK et Ada.
La partie VI fournira les annexes à ce tutoriel : FAQ, Glossaire, présentation de librairies tierces ...
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. Ils seront pour vous l'occasion de mettre en application vos connaissances acquises.
Ces travaux pratiques sont signalés dans leur titre par la notation [TP#] (le symbole # étant remplacé par le numéro du TP). De
plus, ils portent tous l'icône :
www.siteduzero.com
Apprendre à programmer avec Ada 8/353
Partie 1 : Premiers pas avec Ada
Qu'est-ce que la programmation ? Qu'est-ce que Ada ? Comment faire pour "programmer en Ada" ? Autant de questions
existentielles auxquelles nous allons répondre dans cette première (et courte) partie.
Programmation, algorithmique et Ada ?
Nous allons dans ce chapitre répondre à quelques questions préliminaires. Qu'est-ce qu'un programme ? A quoi cela ressemble-t-
il ? Comment crée-t-on un programme ? Qu'est-ce que l'algorithmique ? Pourquoi Ada et 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.
A ceux qui auraient déjà des notions de programmation, vous pouvez bien entendu éviter ce chapitre quoique je ne saurais trop
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 choses à faire comme :
ouvrir une fenêtre
afficher du texte
effectuer des opérations
...
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.
Voici quelques images de programmes :
www.siteduzero.com
Partie 1 : Premiers pas avec Ada 9/353

www.siteduzero.com
Partie 1 : Premiers pas avec Ada 10/353
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.
www.siteduzero.com