Vous êtes sur la page 1sur 25

CPR Informatique

Août 2001
(poste 3159 ou 3164)

Initiation à la
Programmation
Langage algorithmique : 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
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.

IGN / ENSG / CPRI Initiation à la programmation page 3/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)

IGN / ENSG / CPRI Initiation à la programmation page 4/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).

IGN / ENSG / CPRI Initiation à la programmation page 5/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 programme
Entrer dans cuisine
Allumer Lumière
Ces deux actions sont
Ouvrir réfrigérateur quasiment identiques
Prendre oeuf
Fermer réfrigérateur

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é :

Action PrendreDansRéfrigérateur (objet) Procédure ayant pour


Ouvrir Réfrigérateur paramètre : objet
Prendre objet
Fermer Réfrigérateur
Fin PrendreDansRéfrigérateur
Procédure n’ayant pas
de paramètre
Action EntrerDansCuisine ()
Entrer dans cuisine
Allumer lumière
Fin EntrerDansCuisine Le programme débute ici, il « appelle » la
procédure «EntrerDansCuisine » (c’est-à-dire
Début programme exécute les instructions « Entrer dans cuisine » et
EntrerDansCuisine « Allumer lumière ») puis appelle deux fois la
procédure « PrendreDansRéfrigérateur » avec un
PrendreDansRéfrigérateur (œuf) paramètre différent à chaque appel.
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 »

IGN / ENSG / CPRI Initiation à la programmation page 6/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.

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


Classe d’objets Lumière
Caractéristiques :
60 Watts
Comportements :
Allumer
Eteindre
Fin Objets Lumière

Classe d’objets Cuisine :


Caractéristiques :
15 m2
Rez-de-chaussée
Comportement :
Allumer : (Lumière : Allumer)
Fin objets Cuisine « EntrerDans » déclenche l’action « Allumer »
l’objet Pièce, c’est-à-dire appelle la méthode
Classe d’objets EtreHumain « Allumer » de l’objet Pièce qui appelle lui-même
Caractéristiques : la méthode « Allumer » de l’objet Lumière
Nom, prénom
Age
Comportements
EntrerDans (Pièce) : (Pièce : Allumer)
PrendreDans(objet1,objet2) : Ouvrir(objet1), Saisir(objet2),
Fermer(objet1)
Ouvrir (objet)
Fermer (objet)
Saisir (objet)
« Ouvrir » et « Fermer » déclenchent implicitement
Fin objets EtreHumain les actions « Allumer » et « Eteindre » de l’objet si
celui-ci possède les méthodes « Allumer » et
Classe d’objets Réfrigérateur : « Eteindre »
Caractéristiques :
Hauteur
Couleur
Comportement :
Allumer : (Lumière : Allumer)
Lumière : (Lumière : Eteindre)
Fin objets Réfrigérateur 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 les
Début Programme objets à prendre, l’œuf et le beurre.
Etre 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 Compilé Enseignement
une version objet)
ADA Structuré (il existe Compilé Militaire, aérospatiale
une version objet)
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

IGN / ENSG / CPRI Initiation à la programmation page 8/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 Enoncé précis Ecriture des


formulation précise du problème algorithmes Programme

Langage Langage Langages de


courant algorithmique programmation

Analyse Algorithmique Programmation

IGN / ENSG / CPRI Initiation à la programmation page 9/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 :

Condition ? faire quelque chose | faire autre chose ¿

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

5
L’unité de base d’exécution du processeur. Le processeur ne peut exécuter qu’une instruction à la fois.

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


L’algorithme de notre problème sera alors : Lire (EntierUn) signifie : affecter à la variable EntierUn la
valeur tapée au clavier.

Lire (EntierUn) ; Ecrire (phrase) signifie : afficher à l’écran le paramètre


Lire (EntierDeux) ; phrase

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 :

Condition ? faire quelque chose |¿

Partie vide

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 :

A = 1 ? (faire quelque chose) | ¿


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

peuvent être remplacés par : A ?


Cas 1 (faire quelque chose)
Cas 2 (faire quelque chose)
Cas 3 (faire quelque chose)
Cas 10 (faire quelque chose)
(faire quelque chose)
¿
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 ( ).

IGN / ENSG / CPRI Initiation à la programmation page 11/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 :

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 ;

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

Tab 0 0 5 0 0 0 0 0 0 0

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 !

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

IGN / ENSG / CPRI Initiation à la programmation page 12/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.
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.

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.

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

Boucle « Tant que »


On n’entre pas dans la boucle car la
/A<6 condition n’est pas réalisée dès le
A 10 ; Tab 0 ; A A + 2 ; premier test.
A

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 !

Condition ? sortir de la boucle |¿


IGN / ENSG / CPRI Initiation à la programmation page 13/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 ).

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

Quand l’indice est égal à 12 on sort de


la boucle. On exécute ensuite Instr2
mais pas Instr1.

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

Quand l’indice est égal à 12 on ne sort


pas de la boucle mais on recommence la
boucle à l’indice 13 sans exécuter instr1.

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

Quand l’indice est égal à 12 on ne sort pas


de la boucle mais on recommence la
boucle à l’indice 1 sans exécuter instr1.

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

IGN / ENSG / CPRI Initiation à la programmation page 14/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 : 3 7


A B

Situation après la permutation : 7 3


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

3 7 7 7 7 3
A B A B A B

3 3 3
C C C

L’algorithme en ADL :

Ecrire (Entrer les deux valeurs à permuter) ;


Lire (A) ;
Affectent aux variables A et B les valeurs tapées au clavier.
Lire (B) ;

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

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.

IGN / ENSG / CPRI Initiation à la programmation page 15/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 ».

Tab 3 9 1 5 2

Résultat : S 20

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

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

L’initialisation de S est primordiale car si S est


différent de 0 (par exemple 4), on aura au
premier tour de boucle non pas S=0+3, mais
S=4+3, ce qui nous donnera au final une
somme égale à 24 au lieu de 20.

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 : Tab 3 9 1 5 2

Situation après le tri : Tab 1 2 3 5 9

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.

IGN / ENSG / CPRI Initiation à la programmation page 16/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 :

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

temp TabI ; TabI TabRangMin ; TabRangMin temp ;


I

On permute l’élément courant avec le plus


petit trouvé dans la boucle intérieur. On a
besoin d’une troisième variable (temp)
pour la permutation

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 : Tab 3 9 1 5 2


Permutation de 3 et de 1

Etape 1 : Tab 1 9 3 5 2
Permutation de 9 et de 2

Etape 2 : Tab 1 2 3 5 9

IGN / ENSG / CPRI Initiation à la programmation page 17/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.

Début du programme Début Tri ( )


On regroupe ces 3
Instruction1 instructions dans
Instruction1
Instruction2 une procédure Tri ( ) Instruction2
Instruction3 Instruction3
Fin Tri ( )
Instruction4
Instruction5 Début du programme
Instruction1 Tri ( )
Dans le nouveau programme
Instruction2 on « appelle » la procédure Tri
Instruction3 Instruction4
Instruction5
Instruction7
Instruction8 Tri ( )
En cas de modification de Instruction7
Instruction1
l’algorithme de tri, on effectue le
Instruction2 Instruction8
changement du code uniquement
Instruction3 dans la procédure Tri ( ) et non Tri ( )
autant de fois qu’apparaissent les
Fin du programme instructions dans le programme.
Fin du programme

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

IGN / ENSG / CPRI Initiation à la programmation page 18/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.

4,1
temp 0 ; Min TabI ; RanMin I ;
I:1
5,1
TabJ < Min ? Min TabJ ; RangMin J ; |¿
J:I+1 J

temp TabI ; TabI TabRangMin ; TabRangMin temp ;


I

Cette partie de code devient un module

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

Paramètres formels
en entrée-sortie

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


Dans le module de tri on « appelle » le module Permut avec les paramètres actuels.
4,1
temp 0 ; Min TabI ; RanMin I ;
I:1
5,1
TabJ < Min ? Min TabJ ; RangMin J ; |¿
J:I+1 J

Permut ( TabI , Tab RangMin ) ;


I

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.

IGN / ENSG / CPRI Initiation à la programmation page 20/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 !

IGN / ENSG / CPRI Initiation à la programmation page 21/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 ;

IGN / ENSG / CPRI Initiation à la programmation page 22/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.

Type Personne
Nom
Prénom Définition du type Personne
Sexe
Fonction
NumSecSoc

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

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

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


(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 :

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

Permut (A,B): Dans ce cas les paramètres sont « passés » à la


fonction par « valeur » (in).

temp A ; Dans la procédure Permut, on travaille sur les copies


des paramètres réels Entier1 et Entier2 (A et B sont
A B ; des copies de ces paramètres).
B temp ;
La permutation a donc été effectuée à l’intérieur de la
procédure Permut mais n’a pas modifié les valeurs
de Entier1 et Entier2.
Programme ():
Lorsqu’on quitte la procédure, les variables locales
(donc les copies) sont détruites. Entier1 vaut toujours
Entier1 4 ; 4 et Entier2 vaut toujours 5.
Entier2 5 ;
Permut (Entier1,Entier2) ;

Ecrire (Entier1) ;

Ecrire (Entier2) ;

IGN / ENSG / CPRI Initiation à la programmation page 24/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.

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