Professional Documents
Culture Documents
Août 2001
(poste 3159 ou 3164)
Initiation à la
Programmation
Langage algorithmique : ADL
Table des matières
Les trois phases principales de création d’un logiciel sont : l’analyse, l’algorithmique et la
programmation.
Le présent document est destiné à des débutants en programmation. Son but est d’expliquer le plus
simplement possible les notions de base de la programmation et non de former des programmeurs
chevronnés. Nous aborderons donc de façon très succincte la phase d’analyse (Cf. chapitre 3.2)
qui nécessite l’apprentissage de méthodes spécifiques qui ne sont pas nécessairement adaptées à
l’élaboration de programmes simples. Néanmoins, chacun doit garder à l’esprit que la qualité d’un
programme réside principalement dans la qualité de l’analyse réalisée au préalable.
La première partie de ce document traite de la définition, des caractéristiques et de l’évolution des
langages de programmation.
La seconde partie est consacrée à l’algorithmique. Le chapitre débute par une présentation
détaillée des principales notions utilisées en algorithmique et se poursuit par l’étude de trois
algorithmes simples illustrant les différents concepts étudiés. Le langage algorithmique choisit
pour illustrer ces notions est l’ADL (langage enseigné à l’ENSG).
Le reste du document traite des notions de programmation communes à la plupart des langages.
1
Extrait de l’ouvrage de Chantal et Patrice RICHARD : Initiation à la programmation.
2
Pour « faciliter » sa lecture, certains programmeurs confirmés utilisent la notation dans le système hexadécimal (à
peine plus lisible)
Ouvrir réfrigérateur
Prendre beurre
Fermer réfrigérateur
Fin Programme
On remarque que la répétition de la même opération (la suite d’instructions « Ouvrir réfrigérateur
», « Prendre objet », « Fermer réfrigérateur ») nécessite la répétition des mêmes instructions.
Pourtant, il est clair que ces trois instructions correspondent à une seule action : « Sortir un objet
du réfrigérateur ». Seul l’objet diffère à chaque opération. Si le programme doit permettre de sortir
1000 objets du réfrigérateur, il faudra écrire 3000 lignes de programme !
Les langages de programmation « non structurés » sont très simples d’utilisation mais restent
limités dès que le programme devient important. A l’heure actuelle, ils ne sont plus utilisés sauf
comme langage de programmation de certaines calculatrices.
2.3.2.- Les langages structurés
Les langages de programmation « structurés » permettent le regroupement d’instructions
correspondant à une action afin de ne pas répéter le code. Les instructions sont regroupées dans un
« module » appelé procédure ou fonction (nous détaillerons ces notions dans le chapitre 3.5).
Pour différentier l’objet que l’on veut sortir du réfrigérateur il faut le préciser à la procédure.
L’objet est appelé paramètre de la procédure. Une procédure peut avoir aucun, un ou plusieurs
paramètres.
Les langages de programmation « structurés » autorisent également la définition de types
« structures » dont nous parlerons dans le chapitre consacré à la programmation.
Voici le même programme dans sa version structuré :
4
Une classe est un ensemble d’objets de même nature.
MonPremierEntier 4
MonDeuxièmeEntier 6
MonTroisièmeEntier MonPremierEntier + MonDeuxièmeEntier
MonPremierEntier 4 ;
MonDeuxièmeEntier 6 ;
MonTroisièmeEntier MonPremierEntier + MonDeuxièmeEntier ;
3.3.2.1.- Le test
Imaginons que nous voulions écrire l’algorithme formulé ainsi en « français » : définir lequel des
deux chiffres EntierUn et EntierDeux (tapés au clavier) est le plus grand. Nous avons à notre
disposition la notion de variable pour stocker les deux chiffres. La comparaison se traduit par la
structure alternative (le test) suivante :
5
L’unité de base d’exécution du processeur. Le processeur ne peut exécuter qu’une instruction à la fois.
Il n’est pas toujours nécessaire d’effectuer un traitement dans la partie Sinon ( | ) du test. Dans ce
cas le test devient :
Partie vide
Plutôt que d’effectuer plusieurs tests les uns à la suite des autres, il est plus judicieux d’utiliser le
« test à choix multiples » qui permet d’effectuer un traitement en fonction de la valeur d’une
variable. Par exemple, les tests simples et successifs :
Avant de nous intéresser précisément à la notion de boucle, il est intéressant d’introduire la notion
de tableau. Un tableau est une variable (il possède donc un nom) pouvant accueillir un nombre
fini de valeurs de même type6. La représentation d’un tableau de nom « Tab » de 10 éléments dont
chaque valeur est 0, est la suivante :
Tab 0 0 0 0 0 0 0 0 0 0
Pour affecter une valeur dans un tableau il faut préciser l’emplacement exact dans ce tableau. Le
rang de cet emplacement est appelé l’indice du tableau. Exemple : j’affecte la valeur 5 dans la
case d’indice 3 de mon tableau « Tab » (autrement dit au rang 3 du tableau) s’écrit :
Tab 3 5 ;
Tab 0 0 5 0 0 0 0 0 0 0
Revenons à nos boucles et examinons la boucle « Pour » qui est utilisée lorsque l’on connaît a
priori le nombre de répétitions.
Imaginons que notre programme réalise l’affectation de 100 valeurs dans un tableau « Tab » de
100 cases. Si vous ne connaissez pas l’existence des structures répétitives, votre algorithme
comportera 100 lignes et ressemblera à :
Tab1 0 ;
Tab2 0 ;
Tab3 0 ;
Tab4 0 ;
Tab5 0 ;
...
Tab99 0 ;
Tab100 0 ;
100 , 1
TabIndice 0 ;
Indice : 1 Indice
6
La notion de type sera détaillé plus tard. En simplifiant : on ne peut pas avoir dans un tableau un mélange de données
différentes (par exemple des chiffres et des lettres).
La boucle « Tant que » est utilisée quand on ne connaît pas a priori le nombre de répétitions
d’instructions à effectuer. La condition d’arrêt de la boucle est par exemple calculée au sein même
de la boucle. Exemple : on répète les instructions de la boucle tant qu’une variable n’a pas atteint
une certaine valeur.
Au 4ème tour de boucle A vaut 7 et la
condition A < 6 n’est plus respectée.
/A<6 On ne rentre donc plus dans la boucle.
A 1 ; Tab A 0 ; A A + 2 ; Dans ce cas, seuls Tab1, Tab3 et Tab5
sont affectées à 0.
Le principe est le même que celui de la boucle « Tant que » à savoir qu’on ne connaît pas le
nombre de répétitions à effectuer. La seule différence est que dans le cas de la boucle « Jusqu’à ce
que » on passe toujours au moins une fois dans la boucle quelque soit la condition d’arrêt.
/A<6
A 10 ; Tab A
0 ; A A + 2 ;
Boucle « Jusqu’à ce que »
On entre une fois dans la boucle et le
test est réalisé après.
Il s’agit d’une boucle dont les instructions se répètent à l’infini. On peut sortir d’une telle boucle
par une instruction de débranchement (Cf. Chapitre suivant) effectuée par exemple à l’issue d’un
test. Attention : l’oubli d’une instruction de débranchement dans une telle boucle génère un
programme qui ne s’arrête pas !
100 , 1
TabIndice 0 ; Indice = 12 ?!|¿ Instr1 ; Instr2 ;
Indice : 1 Indice
100 , 1
TabIndice 0 ; Indice = 12 ? |¿ Instr1 ; Instr2 ;
Indice : 1 Indice
100 , 1
TabIndice 0 ; Indice = 12 ? |¿ Instr1 ; Instr2 ;
Indice : 1 Indice
L’instruction Goto
La plupart des langages de programmation permettent de réaliser des débranchements « à tout
moment » et « n’importe où » en mettant à la disposition du programmeur l’instruction Goto.
L’abus d’utilisation de cette instruction est très néfaste à la lisibilité et à la maintenance d’un code
source. Elle est donc à proscrire autant que possible en programmation et doit être évitée en
algorithmique (l’instruction n’existe pas en ADL).
Comme pour les verres, la permutation de nos deux variables A et B nécessite une troisième
variable C. Décomposons les trois étapes avant d’écrire l’algorithme.
3 7 7 7 7 3
A B A B A B
3 3 3
C C C
L’algorithme en ADL :
C A ;
A B ; Opérations de permutation
B C ;
Remarque : si nous n’avions pas utilisé une troisième variable et écrit simplement A B ;
B A ; nous aurions eu après exécution de la première instruction A 7 et B 7 et le même
résultat après exécution de la deuxième instruction. La valeur de A aurait alors été perdue. Il est
important de comprendre qu’à un instant donné, une variable ne peut contenir qu’une seule
valeur.
Tab 3 9 1 5 2
Résultat : S 20
Nous sommes en présence d’une structure répétitive dont nous connaissons le nombre de
répétitions à effectuer (5). Nous pouvons donc utiliser la boucle « Pour ».
5,1
S 0 ; S S + TabIndice ; Ecrire (S) ;
Indice : 1 Indice
7
Le tri que nous avons choisi n’est pas le plus performant. Ce n’est pas le but de cet exercice.
L’algorithme en ADL :
4,1
On compare deux à deux et on conserve
temp 0 ; Min TabI ; RanMin I ; le plus petit élément ainsi que son rang
I:1
5,1
TabJ < Min ? Min TabJ ; RangMin J ; |¿
J:I+1 J
Etape 1 : Tab 1 9 3 5 2
Permutation de 9 et de 2
Etape 2 : Tab 1 2 3 5 9
Les procédures comme les fonctions peuvent avoir des paramètres. Par exemple, la fonction
mathématique « Sin » qui calcule le sinus d’un angle a pour paramètre l’angle dont on veut
calculer le sinus. C’est une fonction, puisque le calcul du sinus de l’angle est renvoyé à
l’utilisateur. Le fait de « fournir » des paramètres à un module est appelé : le passage des
paramètres au module.
Comme on peut le voir sur le schéma ci-dessus, il faut distinguer la définition du module de
l’appel du module. Comme le module doit pouvoir être utilisé dans d’autres programmes, les
4,1
temp 0 ; Min TabI ; RanMin I ;
I:1
5,1
TabJ < Min ? Min TabJ ; RangMin J ; |¿
J:I+1 J
Paramètres formels
en entrée-sortie
Paramètres actuels
à l’appel de Permut
La variable « temp » est définie à l’intérieur de la procédure « Permut ». Toute variable définie à
l’intérieur d’un module est appelée variable locale et est détruite dès que l’on sort du module. La
variable ne peut donc être utilisée qu’à l’intérieur de « Permut », elle n’est pas « connue » à
l’extérieur ; on parle de la « portée » de la variable.
Remarque : les noms des paramètres formels sont génériques (ici A et B) alors que les noms des
paramètres actuels sont explicites.
4.1.- La syntaxe
4.1.1.- Généralités
Les langages de programmation ont une syntaxe rigoureuse qu’il est impératif de respectée sous
peine de ne jamais voir compiler, interpréter ou exécuter une seule de vos lignes de code.
Certains langages sont "sensibles à la casse", ce qui signifie qu'un nom ne comportant que des
minuscules ne sera pas considéré comme équivalent au même nom comprenant des majuscules.
Par exemple, la variable "Toto" est différente de la variable "toto", elle-même différente de la
variable « ToTo ».
De plus, un espace (" ") est en réalité un caractère à part entière, on ne peut donc pas mettre un
espace dans un nom de variable. Les noms de variables admettent généralement une longueur
maximale (qui dépend du langage) et un jeu de caractères réduit, parmi lesquels on retrouve
généralement : les lettres de l’alphabet en minuscules et en majuscules, les chiffres (0 à 9) et le
blanc souligné («_»). Beaucoup de langage interdisent que le premier caractère d’un nom de
variable soit un chiffre.
Les commentaires servent à clarifier un programme en donnant des explications. Ils servent aussi
bien au concepteur du logiciel (dans le cas où celui reprend le programme quelques mois ou
quelques années plus tard) qu’à toute autre personne désirant comprendre le code source. Les
commentaires sont le plus souvent écrits :
• en début de programme pour expliquer le but de celui-ci et tout autre renseignement
d’ordre général (le concepteur, la date de création, les éventuelles dates de
modification, …) ;
• en début de chaque module (but du module, description des paramètres, …) ;
• à certains endroits « sensibles » du programme (explication d’une astuce méritant des
explications, partie d’algorithme compliquée, …).
Certains langages (Java notamment) possèdent des utilitaires permettant de générer directement
une documentation à partir des commentaires du code source. Il s’agit d’une motivation
supplémentaire pour commenter ses programmes de façon abondante et détaillée !
En ADL En programmation
MaVariable 0; Entier MaVariable ;
MaVariable = 0 ;
Type Personne
Nom
Prénom Définition du type Personne
Sexe
Fonction
NumSecSoc
• par référence : on « passe » à la fonction, non pas une copie du paramètre, mais une référence
8
La distinction existe dans certains langages (par exemple en ADA).
Permut (A,B):
Dans ce cas les paramètres sont « passés » à la
temp A ; fonction par « référence » (inout).
A B ; Lorsqu’on travaille sur A et B dans la procédure
B temp ; Permut, on travaille effectivement sur les paramètres
réels Entier1 et Entier2 (via les références - A et B
sont les adresses des paramètres réels).
Programme (): La permutation a donc bien été effectuée. Entier1
vaut 5 et Entier2 vaut 4 lors de l’écriture à l’écran
après appel de la procédure.
Entier1 4 ;
Entier2 5 ;
Permut (Entier1,Entier2) ;
Ecrire (Entier1) ;
Ecrire (Entier2) ;
Ecrire (Entier1) ;
Ecrire (Entier2) ;
Un fichier texte (ou ASCII) est un fichier contenant des caractères, des espaces, des signes de
ponctuation, des « retour chariot », des tabulations et un symbole de fin de fichier mais aucune
information de mise en forme. On peut relire un fichier texte avec n’importe quel éditeur de texte.
Un fichier binaire est une suite d’informations binaires (suite de 0 et de 1) très souvent structurées
en enregistrements. Pour relire un fichier binaire il est nécessaire de connaître la structure. Un
fichier binaire ne peut pas être lu par un éditeur de texte.
Actuellement, la plupart des logiciels on besoin d’accéder à des données ou d’écrire des données.
Ces données, souvent volumineuses, sont stockées dans des fichiers (texte ou binaire). La grande
majorité des langages de programmation fournissent des modules (regroupés dans des
bibliothèques ou librairies) permettant l’ensemble des opérations suivantes sur les fichiers : créer
un nouveau fichier, ouvrir et fermer un fichier existant, lire le contenu d’un fichier, écrire et se
positionner dans un fichier.
La plupart des langages actuels permettent également d’accéder via des bibliothèques spécifiques
à des bases de données (Access, Oracle …). Ces bases de données sont implantées sous forme de
fichiers particuliers organisés de façon structurée.