initiation à la programmation ADL

25
CPR Informatique (poste 3159 ou 3164) Août 2001 I I n n i i t t i i a a t t i i o o n n à à l l a a P P r r o o g g r r a a m m m m a a t t i i o o n n L L a a n n g g a a g g e e a a l l g g o o r r i i t t h h m m i i q q u u e e : : A A D D L L

description

Programmation ADL

Transcript of initiation à la programmation ADL

Page 1: initiation à la programmation ADL

CPR Informatique

(poste 3159 ou 3164)

Août 2001

IInniittiiaattiioonn àà llaa PPrrooggrraammmmaattiioonn

LLaannggaaggee aallggoorriitthhmmiiqquuee :: AADDLL

Page 2: initiation à la programmation ADL

Table des matières

1.- INTRODUCTION .................................................................................................................................................3

2.- LES LANGAGES DE PROGRAMMATION .....................................................................................................4 2.1.- QUELQUES DEFINITIONS....................................................................................................................................4 2.2.- LANGAGES INTERPRETES - LANGAGES COMPILES .............................................................................................4 2.3.- VERS DES LANGAGES DE PLUS EN PLUS EVOLUES..............................................................................................5

2.3.1.- Les langages non structurés .....................................................................................................................6 2.3.2.- Les langages structurés ............................................................................................................................6 2.3.3.- Les langages orientés objet ......................................................................................................................7 2.3.4.- Liste non exhaustive des langages les plus courants................................................................................8

3.- L’ALGORITHMIQUE .........................................................................................................................................9 3.1.- DEFINITIONS .....................................................................................................................................................9 3.2.- UN MOT SUR LA PHASE D’ANALYSE ..................................................................................................................9 3.3.- LES BASES DE L’ALGORITHMIQUE...................................................................................................................10

3.3.1.- L’affectation ...........................................................................................................................................10 3.3.2.- Les structures alternatives......................................................................................................................10 3.3.3.- Les structures répétitives........................................................................................................................12 3.3.4.- Les débranchements ...............................................................................................................................13 3.3.4.- Les débranchements ...............................................................................................................................14

3.4.- QUELQUES ALGORITHMES ELEMENTAIRES EN ADL........................................................................................15 3.4.1.- Permutation de deux variables...............................................................................................................15 3.4.2.- Calcul de la somme des éléments d’un tableau......................................................................................16 3.4.3.- Tri d’un tableau......................................................................................................................................16

3.5.- LES MODULES .................................................................................................................................................18 3.5.1.- Définition................................................................................................................................................18 3.5.2.- Procédure et fonction .............................................................................................................................18 3.5.3.- Exemple d’utilisation des modules .........................................................................................................19

4.- LA PROGRAMMATION...................................................................................................................................21 4.1.- LA SYNTAXE ...................................................................................................................................................21

4.1.1.- Généralités .............................................................................................................................................21 4.1.2.- Mots réservés..........................................................................................................................................21 4.1.3.- Les commentaires...................................................................................................................................21 4.1.4.- Les instructions ......................................................................................................................................22

4.3.- TYPE DE DONNEES ET VARIABLE.....................................................................................................................22 4.4.- LE MODE DE PASSAGE DES PARAMETRES A UN MODULE..................................................................................23 4.5.- LES FICHIERS ..................................................................................................................................................25

Page 3: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 3/25

1.- Introduction « Une bonne programmation est celle qui permet à un programme de vivre, c’est-à-dire de s’adapter. Tout logiciel (programme d’application) doit pouvoir évoluer en fonction de facteurs souvent difficiles, voire impossible à prévoir lors de la conception. Si l’analyse du programme a été élaborée avec soin, selon des normes précises, avant d’être traduite en programme, ce dernier pourra facilement être modifié par son concepteur ou par quelqu’un d’autre. »1 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.

Page 4: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 4/25

2.- Les langages de programmation

2.1.- Quelques définitions Un langage de programmation est destiné à décrire l'ensemble des actions consécutives qu'un ordinateur doit exécuter. A l’instar des langages naturels (l'anglais, le français), qui permettent à un groupe d'individus de communiquer, le langage de programmation est une manière pratique pour les humains de donner des ordres à un ordinateur. Attention, les langages permettant aux ordinateurs de communiquer entre eux n'ont rien à voir avec des langages informatiques, on parle dans ce cas de protocoles, ce sont deux notions totalement différentes. Nous n’aborderons pas la notion de protocole dans ce document.

Le langage utilisé par le processeur, c'est-à-dire les données telles qu'elles lui parviennent, est appelé le langage machine (c’est une suite de 0 et de 1 encore appelé système binaire2). Ce langage machine étant très difficilement compréhensible par l'humain, il est indispensable d’avoir recours à un langage intermédiaire qui sera ensuite transformé en langage machine pour être exploitable par le processeur. Ce langage intermédiaire est appelé le langage de programmation. On distingue plusieurs catégories de langages de programmation que nous allons classifier dans les chapitres à venir.

Un programme informatique est une succession d'instructions exécutable par l'ordinateur. La façon d'écrire un programme est très liée au langage de programmation que l'on a choisi. D'une manière générale, le programme est un simple fichier texte (écrit avec un traitement de texte ou un éditeur de texte), que l'on appelle fichier source.

Le fichier source contient les lignes de programmes que l'on appelle code source. Ce fichier source une fois terminé doit être compilé ou interprété.

2.2.- Langages interprétés - Langages compilés Comme nous venons de le dire, les instructions écrites dans un langage de programmation doivent être traduites en langage machine pour être exploitable par le processeur. Cette traduction dépend du type de langage utilisé :

• S’il s’agit d’un langage interprété, la traduction nécessite l’emploi d'un programme auxiliaire, appelé interpréteur, qui traduit et exécute au fur et à mesure les instructions du programme ;

• S’il s’agit d’un langage compilé, le programme est traduit une fois pour toutes par un programme annexe, appelé compilateur, afin de générer un nouveau fichier qui sera autonome, c'est-à-dire qui n'aura plus besoin d'un autre programme pour s'exécuter (on parle dans ce cas de fichier exécutable).

La compilation se déroule en deux étapes :

• Le compilateur transforme le code source en code objet puis le sauvegarde dans un fichier objet, c'est-à-dire qu'il traduit le fichier source en langage machine ;

• Le compilateur fait ensuite appel à un éditeur de liens (en anglais linker) qui permet d'intégrer dans le fichier final tous les éléments annexes (fonctions ou librairies) auxquels le programme fait référence mais qui ne sont pas stockés dans le fichier source.

Un fichier exécutable qui contient tout ce dont il a besoin pour fonctionner de façon autonome est créé à l’issue de la phase d’édition de liens.

2 Pour « faciliter » sa lecture, certains programmeurs confirmés utilisent la notation dans le système hexadécimal (à peine plus lisible)

Page 5: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 5/25

Avantages et inconvénients Un programme écrit dans un langage compilé est autonome et plus rapide à l'exécution. Par contre, il est moins souple qu’un programme écrit dans un langage interprété car à chaque modification du fichier source, il faut recompiler le programme afin de rendre les modifications effectives.

Un programme compilé garantit une meilleure sécurité du code source (le code binaire est difficilement déchiffrable). A l’inverse, le code d’un programme écrit dans un langage interprété est directement lisible et permet à n'importe qui, connaissant la syntaxe du langage utilisé, de « percer les secrets » de fabrication d'un programme, de copier le code, voire de le modifier. Il y a donc risque de non-respect des droits d'auteur. D'autre part, certaines applications sécurisées nécessitent la confidentialité du code pour éviter le piratage (transaction bancaire, paiement en ligne, communications sécurisées, ...).

Certains langages (LISP, Java, ...) appartiennent aux deux catégories puisque le programme peut dans certaines conditions subir une phase de compilation intermédiaire vers un fichier écrit dans un langage qui n'est pas intelligible (donc différent du fichier source) et non exécutable (nécessitant un interpréteur). Les applets Java, petits programmes autonomes parfois insérés dans les pages Web, sont des fichiers qui sont compilés mais que l'on ne peut exécuter qu'à partir d'un navigateur internet ou d’un logiciel spécifique.

2.3.- Vers des langages de plus en plus évolués Le premier langage de programmation ayant été utilisé est un langage très proche du langage machine : l’assembleur. Il subsiste aujourd’hui encore des programmeurs spécialisés développant des applications très spécifiques en assembleur. Ce langage est difficilement compréhensible mais permet d’écrire des applications extrêmement rapides. Il dépend étroitement du type de processeur utilisé (chaque type de processeur peut avoir son propre langage machine). Ainsi un programme développé pour une machine ne pourra pas être « porté » sur un autre type de machine (on désigne par « portable » un programme pouvant être utilisé sur des machines différentes). Pour pouvoir utiliser une application écrite en assembleur sur une autre machine il faut le plus souvent réécrire entièrement le programme. Ceci va à l’encontre des principes de programmation enseignés aujourd’hui qui prônent au contraire la réutilisation du code existant. Depuis l’assembleur, beaucoup de langages de programmation ont vu le jour. Aujourd’hui, les langages sont de plus en plus simples à utiliser, permettant une plus grande portabilité et une plus grande facilité d’adaptation. Il est possible de classifier ces différents langages en trois grandes familles : les langages « non structurés », les langages « structurés », les langages « orienté objet ». Cette classification correspond également à l’évolution chronologique des langages de programmation (Cf. tableau récapitulatif chapitre 2.3.4).

Page 6: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 6/25

2.3.1.- Les langages non structurés On désigne par « non structuré » une suite d’actions à exécuter dans l’ordre de leur arrivée sans se soucier de les ordonner ou de les regrouper. Le langage « non structuré » le plus connu est le Basic. Imaginons un programme « non structuré » qui simule certaines actions de la vie courante :

Début programmeEntrer dans cuisineAllumer Lumière

Ouvrir réfrigérateurPrendre oeufFermer réfrigérateur

Ouvrir réfrigérateurPrendre beurreFermer 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é :

Action PrendreDansRéfrigérateur (objet)Ouvrir RéfrigérateurPrendre objetFermer Réfrigérateur

Fin PrendreDansRéfrigérateur

Action EntrerDansCuisine ()Entrer dans cuisineAllumer lumière

Fin EntrerDansCuisine

Début programmeEntrerDansCuisinePrendreDansRéfrigérateur (œuf)PrendreDansRéfrigérateur (beurre)

Fin programme

Un langage « structuré » permet un découpage du programme ce qui le rend beaucoup plus lisible et beaucoup plus modulable qu’un programme écrit en langage « non structuré »3. 3 C’est la mise en pratique de l’adage « Diviser pour mieux régner »

Ces deux actions sontquasiment identiques

Procédure ayant pourparamètre : objet

Procédure n’ayant pasde paramètre

Le programme débute ici, il « appelle » laprocédure «EntrerDansCuisine » (c’est-à-direexécute les instructions « Entrer dans cuisine » et« Allumer lumière ») puis appelle deux fois laprocédure « PrendreDansRéfrigérateur » avec unparamètre différent à chaque appel.

Page 7: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 7/25

2.3.3.- Les langages orientés objet

La différence entre un langage « structuré » et un langage « orienté objet » est beaucoup moins évidente à décrire à première vue. Il s’agit avant tout d’un mode de pensée très différent. En langage « structuré » on programme l’enchaînement d’actions, en langage orienté objet on programme les objets eux-mêmes (qui possèdent des caractéristiques et des comportements) et les interactions entre ces objets. L'approche « objet » est aujourd’hui une solution technologique incontournable. Ce n'est plus une mode mais un réflexe quasi automatique dès lors que l’on cherche à concevoir des logiciels complexes qui doivent « résister » à des évolutions incessantes. Programmer en « orienté objet », c'est aussi bénéficier d'une panoplie d'outils et de langages performants. Cependant il ne suffit pas de maîtriser un langage de programmation « orienté objet » pour programmer correctement en « orienté objet ». Cette approche nécessite une grande rigueur tant au niveau de l’analyse du problème que de la programmation.

Reprenons notre exemple pour illustrer ces propos et montrer que différentes solutions sont envisageables suivant la vision du problème. Il semble assez clair que nous sommes en présence des classes4 d’objets suivantes : Réfrigérateur, Cuisine, Lumière et Etre humain. Par contre, en ce qui concerne les actions rien n’est défini a priori. Prenons comme exemple l’action « Allumer lumière ». Cette action est-elle un comportement de l’objet Lumière ou de l’objet Etre humain ? La réponse dépend dans ce cas du type de la lumière. En effet, si la lumière s’allume automatiquement à l’entrée d’un être humain dans la pièce, l’action « Allumer » est un comportement de l’objet Lumière. Si au contraire la lumière s’allume quand l’être humain actionne l’interrupteur, il s’agit d’un comportement de l’objet être humain. On voit bien dans cet exemple qu’un problème insuffisamment analysé peut avoir des répercussions désastreuses sur la programmation. Ci-dessous une interprétation possible en « orienté objet » du programme précédent. Pour un débutant en programmation le code peut paraître plus difficile à comprendre. Néanmoins, avec un peu d’habitude il devient plus lisible que le code d’un programme écrit en langage structuré. Il est également plus fiable, plus modulable, plus facile à modifier et permet de réaliser des actions nettement plus complexes. Les classes objets ainsi définies peuvent également être facilement réutilisées dans d’autres programmes.

4 Une classe est un ensemble d’objets de même nature.

Page 8: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 8/25

Classe d’objets LumièreCaractéristiques :

60 WattsComportements :

AllumerEteindre

Fin Objets Lumière

Classe d’objets Cuisine :Caractéristiques :

15 m2Rez-de-chaussée

Comportement :Allumer : (Lumière : Allumer)

Fin objets Cuisine

Classe d’objets EtreHumainCaractéristiques :

Nom, prénomAge

ComportementsEntrerDans (Pièce) : (Pièce : Allumer)PrendreDans(objet1,objet2) : Ouvrir(objet1), Saisir(objet2),

Fermer(objet1)Ouvrir (objet)Fermer (objet)Saisir (objet)

Fin objets EtreHumain

Classe d’objets Réfrigérateur :Caractéristiques :

HauteurCouleur

Comportement :Allumer : (Lumière : Allumer)Lumière : (Lumière : Eteindre)

Fin objets Réfrigérateur

Début ProgrammeEtre humain : EntrerDans (cuisine)Etre humain : Ouvrir (Réfrigérateur)Etre humain : PrendreDans(Réfrigérateur, œuf)Etre humain : PrendreDans(Réfrigérateur, beurre)

Fin Programme

2.3.4.- Liste non exhaustive des langages les plus courants Langage Type Compilé/Interprété Domaine d’application Basic Non structuré Interprété Apprentissage Cobol Structuré Compilé Gestion Fortran Structuré Compilé Calculs PL1 Structuré Compilé Industrie C Structuré Compilé Programmation système Pascal Structuré (il existe

une version objet) Compilé Enseignement

ADA Structuré (il existe une version objet)

Compilé Militaire, aérospatiale

LISP Structuré Interprété et compilé Intelligence artificielle Visual Basic Orienté objet Interprété ou compilé Interfaces homme-machine C++ Orienté objet Compilé Industrie Java Orienté objet Interprété et compilé Industrie – Internet

« EntrerDans » déclenche l’action « Allumer »l’objet Pièce, c’est-à-dire appelle la méthode« Allumer » de l’objet Pièce qui appelle lui-mêmela méthode « Allumer » de l’objet Lumière

« Ouvrir » et « Fermer » déclenchent implicitementles actions « Allumer » et « Eteindre » de l’objet sicelui-ci possède les méthodes « Allumer » et« Eteindre »

Au début du programme on détermine les« vrais » objets. Ici, la Pièce devient la cuisine, l’objet à ouvrir et à fermer, le réfrigérateur et lesobjets à prendre, l’œuf et le beurre.

Page 9: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 9/25

3.- L’algorithmique

3.1.- Définitions Un algorithme est l’expression de l’ensemble des opérations à effectuer sur des ensembles de données pour aboutir à des ensembles de résultats.

L’algorithmique est la phase d’élaboration et d’écriture de l’ensemble des algorithmes nécessaires à la conception d’un logiciel.

Comme pour les langages de programmation, il existe différents langages algorithmiques. Dans ce document nous utiliserons le langage ADL enseigné à l’ENSG (langage extrêmement concis).

L’intérêt de passer par un langage algorithmique est d’écrire un programme sans se soucier de la syntaxe du langage de programmation utilisé. Le travail de passage d’un langage algorithme à n’importe quel langage de programmation n’est plus alors qu’une « simple » traduction.

3.2.- Un mot sur la phase d’analyse Avant la phase algorithmique, il est important de formuler le problème de façon précise dans « la langue de tous les jours ». L’algorithme n’est finalement rien d’autre que la formulation dans un langage plus concis d’un problème clairement énoncé. Cette phase d’analyse doit être d’autant plus approfondie et détaillée que le problème est complexe. On n’analysera pas de la même façon la mise en place d’une chaîne de production automatisée dans une grande entreprise et le tri d’un tableau de dix éléments. Les personnes chargées d’analyser un problème important ont à leur disposition diverses méthodes (Merise, HBDS, SADT, UML, …) pour mener à bien leur projet.

Le but de ce document étant d’apprendre les rudiments de la programmation, nous ne traiterons pas de problèmes nécessitant l’utilisation de telles méthodes. Néanmoins, nous constaterons tout au long de ce chapitre que la formulation précise d’un problème simplifie la phase algorithmique et de fait la traduction de l’algorithme dans un langage de programmation.

Problème sans formulation précise

Enoncé précis du problème

Langage courant

Ecriture des algorithmes

Langage algorithmique

Programme

Langages de programmation

Algorithmique Programmation Analyse

Page 10: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 10/25

3.3.- Les bases de l’algorithmique

3.3.1.- L’affectation Les langages algorithmiques (tout comme les langages de programmation) utilisent la notion de variable. En algorithmique, une variable est l’association d’un nom et d’un contenu (nous verrons par la suite que la notion de variable est un peu plus complexe en programmation). Ainsi, on pourra appeler une variable MonEntier et y stocker le chiffre 4. L’action de stocker une valeur dans une variable est appelée l’affectation. Le symbole utilisé pour l’affectation en ADL est l’opérateur . « J’affecte la valeur 4 à la variable MonEntier » est traduite par : MonEntier 4. Autre exemple : « j’affecte la valeur 4 à la variable MonPremierEntier, j’affecte la valeur 6 à la variable MonDeuxièmeEntier et j’affecte le résultat de l’addition des deux variables à une troisième variable MonTroisièmeEntier » est traduite en ADL par : MonPremierEntier 4

MonDeuxièmeEntier 6

MonTroisièmeEntier MonPremierEntier + MonDeuxièmeEntier

Après cette opération la variable MonTroisièmeEntier contient la valeur 10. L’opération comporte trois actions, ces actions sont appelées instructions5. On délimite souvent les instructions par le symbole « ; ». L’exemple précédent devient alors : MonPremierEntier 4 ;

MonDeuxièmeEntier 6 ;

MonTroisièmeEntier MonPremierEntier + MonDeuxièmeEntier ;

3.3.2.- Les structures alternatives Les programmeurs utilisent plus couramment les termes de « test » et de « test à choix multiples » pour désigner les structures alternatives.

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.

Condition ? faire quelque chose | faire autre chose ¿

Condition réalisée Condition non réalisée

Page 11: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 11/25

L’algorithme de notre problème sera alors : Lire (EntierUn) ;Lire (EntierDeux) ;

EntierUn > EntierDeux ? Ecrire (EntierUn plus grand que EntierDeux) |Ecrire (EntierDeux plus grand que EntierUn) ¿

Il n’est pas toujours nécessaire d’effectuer un traitement dans la partie Sinon ( | ) du test. Dans ce cas le test devient :

3.3.2.2.- Le test à choix multiples

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 :

peuvent être remplacés par : La syntaxe du « test à choix multiples » est plus concise et permet d’effectuer un traitement dans le cas où la variable à tester (ici « A ») contient tout autre valeur non traitée auparavant ( ).

Lire (EntierUn) signifie : affecter à la variable EntierUn lavaleur tapée au clavier. Ecrire (phrase) signifie : afficher à l’écran le paramètrephrase

Condition ? faire quelque chose | ¿

Partie vide

A = 1 ? (faire quelque chose) | ¿A = 2 ? (faire quelque chose) | ¿A = 3 ? (faire quelque chose) | ¿A = 10 ? (faire quelque chose) | ¿

A

Cas 1 (faire quelque chose)Cas 2 (faire quelque chose)Cas 3 (faire quelque chose)Cas 10 (faire quelque chose)

(faire quelque chose)

?

¿

Page 12: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 12/25

3.3.3.- Les structures répétitives Les programmeurs utilisent plus couramment le terme de « boucle » pour désigner les structures répétitives. Une boucle est un ensemble d’instructions exécutées plusieurs fois. On distingue principalement quatre types de boucle : la boucle « Pour », la boucle « Tant que », la boucle « Jusqu’à ce que » et la boucle « Sans fin ». 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 : 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 ;

La représentation des « cases contiguës » du tableau est alors :

3.3.3.1.- La boucle « Pour »

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 ;

L’utilisation de la boucle « Pour » permet d’écrire le même algorithme en seulement 1 ligne !

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).

0 5 0 0 0 0 0 0 00 Tab

0 0 0 0 0 0 0 0 0 0 Tab

TabIndice 0 ;

Indice Indice : 1

100 , 1

Page 13: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 13/25

La variable Indice (appelée « indice de boucle ») est automatiquement incrémentée de 1 à chaque itération (c’est le « pas » de la boucle). Les valeurs 1 et 100 sont appelées respectivement « indice de début » et « indice de fin » de la boucle « Pour ». Comme la variable Indice prend successivement les valeurs 1,2,3,…,100, la variable TabIndice prend successivement les valeurs Tab1, Tab2, …, Tab99, Tab100.

3.3.3.2.- La boucle « Tant que »

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.

3.3.3.3.- La boucle « Jusqu’à ce que »

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.

3.3.3.4.- La boucle « Sans fin »

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 !

A 1 ; Tab A 0 ; A A + 2 ; / A < 6 Au 4ème tour de boucle A vaut 7 et lacondition A < 6 n’est plus respectée.On ne rentre donc plus dans la boucle.Dans ce cas, seuls Tab1, Tab3 et Tab5sont affectées à 0.

Condition ? sortir de la boucle | ¿

Boucle « Jusqu’à ce que » On entre une fois dans la boucle et letest est réalisé après. Boucle « Tant que » On n’entre pas dans la boucle car lacondition n’est pas réalisée dès lepremier test. A 10 ; Tab A 0 ; A A + 2 ; / A < 6

A 10 ; Tab A 0 ; A A + 2 ;

/ A < 6

Page 14: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 14/25

3.3.4.- Les débranchements Un débranchement est une instruction qui permet de ne pas exécuter certaines parties de programme. La sortie d’une boucle « Pour » avant que l’indice de boucle ait atteint l’indice de fin de la boucle est un débranchement. On peut différentier trois types de débranchements : sortir d’une boucle (exit boucle symbolisé par ! ), passer au pas suivant d’une boucle sans effectuer certaines instructions (next symbolisé par ), recommencer une boucle à l’indice de début (reloop symbolisé par ). 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).

TabIndice 0 ; Indice = 12 ? | ¿ Instr1 ; Instr2 ; Indice Indice : 1

100 , 1

Quand l’indice est égal à 12 on ne sortpas de la boucle mais on recommence laboucle à l’indice 13 sans exécuter instr1.

Quand l’indice est égal à 12 on sort dela boucle. On exécute ensuite Instr2mais pas Instr1.

TabIndice 0 ; Indice = 12 ? ! | ¿ Instr1 ; Instr2 ; Indice Indice : 1

100 , 1

TabIndice 0 ; Indice = 12 ? | ¿ Instr1 ; Instr2 ; Indice Indice : 1

100 , 1

Quand l’indice est égal à 12 on ne sort pasde la boucle mais on recommence laboucle à l’indice 1 sans exécuter instr1.

Page 15: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 15/25

3.4.- Quelques algorithmes élémentaires en ADL Nous avons désormais tous les ingrédients nécessaires à l’écriture d’algorithmes. Etudions trois algorithmes simples.

3.4.1.- Permutation de deux variables Enoncé du problème : l’algorithme doit permuter deux variables A et B. Situation avant la permutation : Situation après la permutation : Rapprochons ce problème d’une situation de la vie courante. Imaginons que A soit un verre de lait et B un verre d’eau de même capacité. Comment permuter le contenu des deux verres ? Il est évident pour chacun qu’un troisième verre C (d’une capacité au moins égale) est indispensable. Les opérations à effectuer sont donc :

• verser la contenu de A dans C ; • verser la contenu de B dans A ; • verser la contenu de C dans B.

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.

L’algorithme en ADL :

Ecrire (Entrer les deux valeurs à permuter) ;Lire (A) ;Lire (B) ;

C 0 ;

C A ;A B ;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.

3 7

A B

7 3

A B

3 7

A B

3

C

7 7

A B

3

C

7 3

A B

3

C

Affectent aux variables A et B les valeurs tapées au clavier.

Affecte à C la valeur 0. Cette opération est appelée initialisation

Opérations de permutation

Page 16: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 16/25

3.4.2.- Calcul de la somme des éléments d’un tableau Enoncé précis du problème : l’algorithme doit effectuer la somme des éléments d’un tableau et afficher le résultat final. Le tableau de nom « Tab » contient 5 entiers compris entre 1 et 10. Le résultat est affecté dans une variable « S ».

Résultat : Décrivons l’algorithme tel que nous l’expliquerions en français : On ajoute le premier élément du tableau au deuxième élément et on affecte la somme à la variable S. On ajoute le troisième élément du tableau à S et on affecte la nouvelle valeur à S et ainsi de suite jusqu’au cinquième et dernier élément du tableau. 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 ».

3.4.3.- Tri d’un tableau Enoncé précis du problème après analyse : l’algorithme doit effectuer le tri croissant (du plus petit au plus grand) des éléments d’un tableau7. Le tableau de nom « Tab » contient 5 entiers compris entre 1 et 10. On utilisera un seul tableau pour effectuer le tri. Situation avant le tri : Situation après le tri : Décrivons l’algorithme tel que nous l’expliquerions en français : Comparer le premier élément du tableau avec tous les autres et permuter à chaque fois qu’un plus petit est rencontré. Ainsi on « remonte » le plus petit vers le rang 1 du tableau. Réitérer cette opération à partir du rang 2, puis du rang 3 … jusqu’au rang 4 (ce n’est pas la peine de tester le dernier qui est forcément le plus grand à la fin). Stocker au fur et à mesure l’élément le plus petit dans une variable « Min » en n’oubliant pas de stocker son rang dans une variable RangMin (indispensable pour la permutation).

7 Le tri que nous avons choisi n’est pas le plus performant. Ce n’est pas le but de cet exercice.

9 1 5 23 Tab

20 S

9 1 5 2 3Tab

2 3 5 91Tab

L’initialisation de S est primordiale car si S estdifférent de 0 (par exemple 4), on aura aupremier tour de boucle non pas S=0+3, maisS=4+3, ce qui nous donnera au final unesomme égale à 24 au lieu de 20.

S 0 ; S S + TabIndice ; Ecrire (S) ; Indice Indice : 1

5 , 1

Page 17: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 17/25

Réitérer l’opération pour tous les rangs du tableau nécessite l’utilisation d’une boucle « Pour » dont l’indice I varie de 1 à 4.

Comparer les éléments deux à deux nécessite l’utilisation d’un boucle « Pour » à l’intérieur de la première dont l’indice J varie de I+1 à 5. Nous avons également besoin de deux variables : « Min » et « RangMin ». L’algorithme en ADL : En exécutant l’algorithme « à la main » on obtient l’état du tableau à chaque étape. On constate que notre tableau est trié en seulement deux étapes (ceci dépend bien évidemment de la configuration initiale du tableau). Etape initiale : Etape 1 : Etape 2 :

9 1 5 23Tab

9 3 5 21Tab

2 3 5 91Tab

Permutation de 3 et de 1

Permutation de 9 et de 2

temp 0 ; Min TabI ; RanMin I ;

TabJ < Min ? Min TabJ ; RangMin J ;| ¿

temp TabI ; TabI TabRangMin ; TabRangMin temp ;

I

I : 1

4 , 1

J : I + 1

5 , 1

J

On compare deux à deux et on conservele plus petit élément ainsi que son rang

On permute l’élément courant avec le pluspetit trouvé dans la boucle intérieur. On abesoin d’une troisième variable (temp)pour la permutation

Page 18: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 18/25

3.5.- Les modules 3.5.1.- Définition

Comme nous l’avons vu au chapitre 2.3.3, lorsqu’un certain nombre d’instructions est susceptible de se répéter dans le code source d’un programme, il est préférable de regrouper ces instructions dans un module hors du programme principal. Il y a trois raisons principales justifiant l’utilisation des modules :

• gain important en nombre de lignes de code ;

• modularité accrue : les modules écrits et testés peuvent être réutilisés par la suite dans d’autres modules voire dans d’autres programmes ;

• fiabilité accrue : en cas de modification du code d’un module, les changements ont lieu à un seul endroit ce qui minimise les erreurs de frappe et de report.

Remarque : des modules peuvent appeler d’autres modules.

3.5.2.- Procédure et fonction 3.5.2.1.- La différence fondamentale

On distingue principalement deux types de modules : les procédures et les fonctions. La différence entre les deux est qu’une fonction effectue un traitement et renvoie un résultat alors que la procédure effectue un traitement mais ne renvoie aucune valeur. Le calcul de la somme d’un tableau est typiquement une fonction alors que l’affichage des valeurs d’un tableau à l’écran est une procédure. 3.5.2.2.- La notion de paramètre

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

Début du programme Instruction1 Instruction2 Instruction3

Instruction4 Instruction5

Instruction1 Instruction2 Instruction3

Instruction7 Instruction8

Instruction1 Instruction2 Instruction3

Fin du programme

Début Tri ( ) Instruction1 Instruction2 Instruction3 Fin Tri ( ) Début du programme Tri ( )

Instruction4 Instruction5

Tri ( )

Instruction7 Instruction8

Tri ( )

Fin du programme

On regroupe ces 3instructions dansune procédure Tri ( )

Dans le nouveau programme on « appelle » la procédure Tri

En cas de modification del’algorithme de tri, on effectue lechangement du code uniquementdans la procédure Tri ( ) et nonautant de fois qu’apparaissent lesinstructions dans le programme.

Page 19: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 19/25

paramètres définis lors de la définition du module ne doivent pas être spécifiques à une application. Par exemple, la procédure de tri des éléments d’un tableau doit fonctionner quel que soit le nombre d’éléments du tableau et pas seulement pour un tableau de 10 éléments. Ces paramètres sont appelés les paramètres formels. Lors de l’appel du module on « passe » à la procédure les « vrais » paramètres, il sont appelés paramètres actuels.

Un module fonctionne un peu comme un moule à tarte. Lors de la fabrication du moule (qui correspond à la définition du module), on ne sait pas s'il va servir à faire une pizza, une quiche lorraine ou une tarte au pomme. On le fabrique en sachant qu’il sera utilisable quels que soient les ingrédients (ce sont les paramètres formels). Par contre lorsque le cuisinier ou la cuisinière utilise le moule à tarte (qui correspond à l’appel du module), on utilise le moule avec les « vrais ingrédients » (ce sont les paramètres actuels). On distingue trois modes de passage des paramètres à un module : les paramètres qui ne sont pas modifiés par le module (en entrée), les paramètres issus du module (en sortie, à ne pas confondre avec le paramètre de retour d’une fonction) et les paramètres mis à jour dans le module (en entrée-sortie). Il est très important de préciser cette information dans la phase algorithmique car elle entraîne des différences très importantes lors de la traduction dans un langage de programmation.

3.5.3.- Exemple d’utilisation des modules

Pour illustrer les notions qui viennent d’être abordées, reprenons l’exemple de l’algorithme de tri vu au chapitre 3.4.3. On remarque que la permutation de deux éléments peut être regrouper dans une procédure plus générale pouvant être utilisée dans un autre contexte. Appelons cette procédure « Permut ». Elle a deux paramètres qui correspondent aux deux variables à permuter.

Paramètres formelsen entrée-sortie

Permut ( A, B ) : temp A ; A B ; B temp ;

Cette partie de code devient un module

temp 0 ; Min TabI ; RanMin I ;

TabJ < Min ? Min TabJ ; RangMin J ;| ¿

temp TabI ; TabI TabRangMin ; TabRangMin temp ;

I

I : 1

4 , 1

J : I + 1

5 , 1

J

Page 20: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 20/25

Dans le module de tri on « appelle » le module Permut avec les paramètres actuels.

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.

temp 0 ; Min TabI ; RanMin I ;

TabJ < Min ? Min TabJ ; RangMin J ;| ¿

Permut ( TabI , Tab RangMin ) ;

I : 1

4 , 1

J : I + 1

5 , 1

J

I

Paramètres actuelsà l’appel de Permut

Page 21: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 21/25

4.- La programmation Ce chapitre ne s’intéresse pas à un langage particulier. Il décrit simplement les caractéristiques communes à la plupart des langages de programmation.

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.

4.1.2.- Mots réservés Dans la plupart des langages, il existe une poignée de mots que l'on ne peut pas attribuer aux noms de variables, ce sont les mots réservés (ou mots clés) du langage. Les compilateurs les reconnaissent comme tels et génèrent le code machine adéquat. Ces mots sont différent d’un langage à l’autre même si on retrouve certains d’entre eux dans la plupart des langages.

4.1.3.- Les commentaires Il est généralement intéressant de pouvoir ajouter dans un programme des lignes de texte qui ne sont pas prises en compte par le compilateur ou l’interpréteur. Ces lignes de texte sont généralement précédées (ou encadrées) par des instructions spéciales qui signaleront au compilateur ou à l’interpréteur de les ignorer. Ces lignes de texte sont généralement appelées commentaires. 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 !

Page 22: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 22/25

4.1.4.- Les instructions L'instruction est l'élément clé de l'ordinateur car c'est elle qui permet de spécifier au processeur l'action à effectuer. Les instructions à effectuer sont indiquées dans le fichier source et l'ordinateur passe d'une instruction à une autre en suivant les instructions indiquées de haut en bas (car la lecture d'un fichier se fait de haut en bas).

Une instruction est généralement composée de deux éléments : • l'opérateur : action à effectuer par le processeur ; • la ou les opérandes : une ou plusieurs données sur lesquelles on va effectuer l'opération

opérateur - opérande(s). On distingue généralement deux ou trois types d'opérateurs :

• Les opérateurs unaires : ce sont des opérateurs qui n'admettent qu'une seule opérande ; • Les opérateurs binaires : ce sont des opérateurs qui, contrairement à ce que l'on pourrait

croire, ne travaillent pas sur des opérandes binaires, mais admettent deux opérandes (binaire désigne donc le nombre d'opérandes manipulées, l'opération, souvent notée +, est donc un opérateur binaire) ;

• Les opérateurs ternaires : ce sont des opérateurs qui admettent trois opérandes (les opérateurs conditionnels sont par exemple des opérateurs ternaires) ;

Les opérateurs peuvent aussi être répartis selon plusieurs catégories en fonction du type d'actions que leur exécution déclenche. Citons : les opérateurs arithmétiques, les opérateurs de comparaison, les opérateurs logiques, les opérateurs de bits, les opérateurs d'affectation, les opérateurs conditionnels, les opérateurs séquentiels …

Dans chaque langage il existe généralement des priorités d'évaluation des opérateurs, afin que l'ordinateur sache dans quel sens évaluer les opérateurs lorsque plusieurs d'entre eux sont présents dans une même expression.

4.3.- Type de données et variable Nous avons déjà expliqué ce qu’est une variable du point de vue de l’algorithmique : c’est l’association d’un nom et d’un contenu.

Pour définir une variable du point de vue de la programmation il faut y ajouter la notion de type de variable. En effet, en algorithmique l’affectation d’une valeur à une variable est une notion théorique, en programmation il faut effectivement stocker dans la mémoire de l’ordinateur la valeur de la variable. En d’autres termes, il faut définir la taille de la case d’accueil de la valeur dans la mémoire de l’ordinateur.

Cette notion de taille est étroitement liée à la notion de type de données. La donnée stockée prend plus ou moins de place en mémoire : on ne stocke pas une chaîne de caractères de 100 caractères dans le même emplacement mémoire que le chiffre 4. C’est le type de la variable qui détermine la taille de la case réservée dans la mémoire. Le compilateur réserve la taille en fonction du type de la donnée déclarée dans le code source. On a donc une nouvelle notion qui est la déclaration d’une variable. Exemple : on a besoin d’une variable pouvant accueillir des chiffres compris entre 0 et 100. Ce chiffre est un entier, il faut donc déclarer la variable comme étant d’un type entier :

En ADL En programmation

MaVariable 0 ; Entier MaVariable ; MaVariable = 0 ;

Page 23: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 23/25

Dans la plupart des langages il existe des types de données correspondant à des entiers (normaux, longs, courts), des réels, des chaînes de caractères. La syntaxe est différente d’un langage à un autre (un entier est déclaré Integer en Pascal et int en C++).

Certains langages acceptent que l'on associe à un nom de variable n'importe quel type de donnée (c'est-à-dire aussi bien un nombre entier qu'un caractère), on appelle ces langages des « langages non typés » par opposition aux autres langages « appelés langages typés ».

Les langages « non typés » peuvent a priori être considérés comme étant plus souple d’utilisation (on évite de déclarer les variables, tâche fastidieuse), mais cette souplesse se retourne très vite contre le programmeur dès que le code source devient important. On a alors beaucoup de variables et les erreurs d’affectation, détectées par le typage ne le sont plus, entraînant des lignes de programmes incohérentes et souvent fausses. Ce genre de problème est parfois difficile à trouver dans un code source de plusieurs milliers de lignes. Le peu de temps « gagné » en ne déclarant pas les variables est très rapidement perdu et parfois au centuple !

Tous les langages utilisés dans le domaine de l’industrie sont typés (Pascal, C, C++, Java …).

Certains langages (par exemple Visual Basic) peuvent être utilisés comme des langages typés (une option à préciser au début du programme) mais sont non typés par défaut (un « reste » malheureux de son ancêtre Basic).

Hormis les types prédéfinis, la plupart des langages permettent au programmeur de définir ses propres types de données. La syntaxe est différentes suivant le langage mais le principe est le même. Imaginons que notre programme effectue des traitement sur le personnel d’une entreprise. Dans ce cas il est judicieux de regrouper les caractéristiques communes de toutes les personnes de l’entreprise et de créer un type « Personne ». L’utilisation de variables de ce type facilite la lisibilité du code source ainsi que certaines opérations de programmation.

4.4.- Le mode de passage des paramètres à un module Nous avons vu dans le chapitre 3.5.2.2, qu’il était important de préciser au niveau de l’algorithme le mode de passage des paramètres à un module (procédure ou fonction). Rappelons les trois modes possibles : les paramètres non modifiés par le module (en entrée), les paramètres issus du module (en sortie) et les paramètres mis à jour par le module (en entrée-sortie).

En programmation on distingue rarement les paramètres en sortie de ceux en entrée-sortie8. On ne conserve donc que deux modes : les paramètres modifiés par le module, les paramètres non modifiés par le module. On a donc deux mécanismes de passage des paramètres :

• par valeur : on recopie le paramètre en local dans la fonction et on « travaille » sur la copie du paramètre réel. Lorsque l’on sort du module, les variables locales sont détruites (en particulier la copie de paramètre réel sur laquelle on a travaillé) et le paramètre réel n’a donc pas été modifié. Dans l’algorithme le paramètre est déclaré en entrée (in symbolisée en ADL par ) ;

• 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).

Type PersonneNomPrénomSexeFonctionNumSecSoc

Fin Type Déclaration d’une variable de type Personne

Définition du type Personne

Page 24: initiation à la programmation ADL

IG

(grosso modo l’endroit où il se trouve dans la mémoire, son « adresse »). On travaille donc directement (via la référence) sur le paramètre réel. Toute modification effectuée sur le paramètre à l’intérieur du module est effectivement réalisée sur la variable qui se trouve à l’extérieur du modume. Dans l’algorithme le paramètre est déclaré en sortie ou en entrée-sortie (out ou inout respectivement symbolisée en ADL par et ).

Prenons un exemple pour illustrer les modes de passage des paramètres :

Dans ce cas les paramètres sont « passés » à lafonction par « référence » (inout). Lorsqu’on travaille sur A et B dans la procédurePermut, on travaille effectivement sur les paramètresréels Entier1 et Entier2 (via les références - A et Bsont les adresses des paramètres réels). La permutation a donc bien été effectuée. Entier1vaut 5 et Entier2 vaut 4 lors de l’écriture à l’écranaprès appel de la procédure.

Permut (A,B):

temp A ;A B ;B temp ;

Programme ():

Entier1 4 ;Entier2 5 ;

Permut (Entier1,Entier2) ;

Ecrire (Entier1) ;

Ecrire (Entier2) ;

N

Dans ce cas les paramètres sont « passés » à lafonction par « valeur » (in). Dans la procédure Permut, on travaille sur les copiesdes paramètres réels Entier1 et Entier2 (A et B sontdes copies de ces paramètres). La permutation a donc été effectuée à l’intérieur de laprocédure Permut mais n’a pas modifié les valeursde Entier1 et Entier2. Lorsqu’on quitte la procédure, les variables locales(donc les copies) sont détruites. Entier1 vaut toujours4 et Entier2 vaut toujours 5.

Permut (A,B):

temp A ;A B ;B temp ;

Programme ():

Entier1 4 ;Entier2 5 ;

Permut (Entier1,Entier2) ;

Ecrire (Entier1) ;

Ecrire (Entier2) ;

/ ENSG / CPRI Initiation à la programmation page 24/25

Page 25: initiation à la programmation ADL

IGN / ENSG / CPRI Initiation à la programmation page 25/25

4.5.- Les fichiers Un fichier est un ensemble complet d’informations, nommé et enregistré par un utilisateur, et stocké sur un support magnétique (bande, disquette, disque, DAT, …) ou optique (CD, ..). 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.