Vous êtes sur la page 1sur 127

Les bases de la programmation

Par Eric Thirion


Date de publication : 16 dcembre 2013
Dernire mise jour : 5 mars 2014
Ce cours peut tre utile toute personne
dsirant s'initier la programmation et
aux bases de donnes. Il s'adresse donc
des dbutants et ne demande aucune
connaissance pralable dans ces deux
domaines.
Depuis 2008, je le remets continuellement
jour en corrigeant les invitables erreurs et
en le rendant plus complet et surtout, plus
pdagogique.
Je l'utilise pour enseigner la partie
dveloppement d'applications du programme
de BTS informatique (formation Bac+2). Il s'agit
donc d'un cours vcu sur le terrain , qui
tient compte des difficults rencontres par les
tudiants.
Les bases de la programmation par Eric Thirion
- 2 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
propos de l'auteur.................................................................................................................................................... 7
Note de la rdaction de Developpez.com..............................................................................................................7
Premires notions de programmation......................................................................................................................... 7
But de ce chapitre.................................................................................................................................................. 7
Un peu d'histoire.................................................................................................................................................... 8
L'ordinateur............................................................................................................................................................. 8
Codage binaire.................................................................................................................................................. 8
Le bit............................................................................................................................................................ 8
Le transistor................................................................................................................................................. 8
L'octet et autres units.............................................................................................................................. 10
Le codage des nombres entiers en base 2.........................................................................................10
Le codage du texte en ASCII.............................................................................................................. 11
Mmoire vive et adresse................................................................................................................................ 12
Langage machine et programme excutable............................................................................................12
Processus........................................................................................................................................................ 14
Les entres-sorties..........................................................................................................................................15
Les interruptions..............................................................................................................................................16
Les Interfaces graphiques.................................................................................................................................... 17
Historique.........................................................................................................................................................17
Interface du systme.......................................................................................................................................19
Le curseur.................................................................................................................................................. 20
Gestion du clic........................................................................................................................................... 20
Fentre d'une application................................................................................................................................20
Les vnements.............................................................................................................................................. 21
Les zones de texte......................................................................................................................................... 22
La programmation.................................................................................................................................................22
Notion de programme..................................................................................................................................... 23
Notion de langage...........................................................................................................................................23
Fichiers sources.............................................................................................................................................. 24
Compilation......................................................................................................................................................24
Notion de compilateur................................................................................................................................24
Exemple de compilation............................................................................................................................ 25
Interprtation.........................................................................................................................................26
Les EDI............................................................................................................................................................27
La programmation vnementielle..................................................................................................................28
Lazarus................................................................................................................................................................. 29
Notion de formulaire........................................................................................................................................29
Gnration automatique de code................................................................................................................... 30
Programmation vnementielle.......................................................................................................................34
Ordre d'excution des instructions............................................................................................................ 35
Notice d'utilisation........................................................................................................................................... 35
Les variables.........................................................................................................................................................36
La notion de variable...................................................................................................................................... 36
Les noms de variables en Pascal............................................................................................................. 36
La notion de type............................................................................................................................................ 37
Dclaration d'une variable...............................................................................................................................38
Dclaration d'une variable en Pascal........................................................................................................38
Syntaxe gnrale..................................................................................................................................38
Dclaration d'un entier......................................................................................................................... 38
Le type double......................................................................................................................................38
Dclaration d'une chane de caractres.............................................................................................. 38
Regroupement des dclarations.......................................................................................................... 38
O faut-il dclarer les variables ?........................................................................................................ 39
Lecture et affichage.............................................................................................................................................. 39
Donnes et rsultats d'un traitement..............................................................................................................39
L'image du sourd-muet qui ne sait pas additionner.................................................................................. 39
Pour un ordinateur.....................................................................................................................................39
Exemple du programme d'addition............................................................................................................40
Les bases de la programmation par Eric Thirion
- 3 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Historique.........................................................................................................................................................41
La procdure writeln.................................................................................................................................. 42
La procdure readln.................................................................................................................................. 43
ETBib............................................................................................................................................................... 43
Exemple d'utilisation des procdures de ETBib........................................................................................43
Lecture des variables........................................................................................................................... 44
Affichage des variables........................................................................................................................ 44
Effacement des zones de texte........................................................................................................... 45
Argumentation pdagogique......................................................................................................................45
Les expressions....................................................................................................................................................46
Les littraux..................................................................................................................................................... 46
Les littraux numriques........................................................................................................................... 47
Les littraux chanes de caractres.......................................................................................................... 47
Les constantes................................................................................................................................................ 47
Dclaration d'une constante en Pascal.....................................................................................................47
Oprateur.........................................................................................................................................................48
La concatnation........................................................................................................................................48
Validit d'une expression................................................................................................................................ 49
Expressions valides de type chane de caractres...................................................................................49
Expressions valides de type numrique................................................................................................... 50
Affichage d'expression.................................................................................................................................... 51
Expression de type chane de caractres.................................................................................................51
Expression numrique............................................................................................................................... 51
Traitement sans variables-rsultats...........................................................................................................52
L'affectation........................................................................................................................................................... 52
criture d'une instruction d'affectation en Pascal........................................................................................... 53
Exemple de code Pascal avec des affectations....................................................................................... 53
Affectation rcursive........................................................................................................................................ 54
Traitement itratif.............................................................................................................................................54
Exemple et conseils............................................................................................................................................. 56
Exemple de programme et conseil................................................................................................................. 57
Cahier des charges................................................................................................................................... 57
Dclaration des constantes....................................................................................................................... 57
Conception de l'interface graphique.......................................................................................................... 57
Lecture et dclaration des donnes.......................................................................................................... 58
Traitement, rsultats intermdiaires et finals.............................................................................................59
Le code de la procdure en entier............................................................................................................59
Synthse.......................................................................................................................................................... 60
Exercices...............................................................................................................................................................60
Sous-programmes...................................................................................................................................................... 61
But de ce chapitre................................................................................................................................................ 61
Introduction........................................................................................................................................................... 61
Dcoupage d'un programme en sous-programmes....................................................................................... 61
Sous-programmes non vnementiels........................................................................................................... 61
Les units........................................................................................................................................................ 62
Procdures et fonctions.................................................................................................................................. 63
Porte des variables.............................................................................................................................................64
Exemple 1 (fichier : Global/ProjetGlobal.lpi)................................................................................................... 64
Exemple 2 (fichier : Local0/ProjetLocal0.lpi)...................................................................................................65
Exemple 3 (fichier : Local1/ProjetLocal1.lpi)...................................................................................................66
Exemple 4 (fichier : Local2/ProjetLocal2.lpi)...................................................................................................67
Synthse.......................................................................................................................................................... 68
Dfinition.................................................................................................................................................... 68
Porte......................................................................................................................................................... 68
Dure de vie.............................................................................................................................................. 68
Dclarations locales multiples................................................................................................................... 68
Dclaration simultane en local et en global............................................................................................ 69
Exemple d'utilisation de sous-programmes..........................................................................................................69
Les bases de la programmation par Eric Thirion
- 4 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Utilisation des procdures...............................................................................................................................69
Exemple 1.................................................................................................................................................. 69
Programmation descendante.....................................................................................................................71
Retour d'un sous-programme.................................................................................................................... 71
Exemple 2.................................................................................................................................................. 72
Dtail technique....................................................................................................................................73
Exemple d'utilisation de fonctions...................................................................................................................74
Ancienne version du projet........................................................................................................................74
Nouvelle version : appel des fonctions..................................................................................................... 75
Nouvelle version : dclaration des fonctions.............................................................................................76
Retour du rsultat...................................................................................................................................... 76
Principes gnraux et complments.................................................................................................................... 78
Dclaration et appel de procdures............................................................................................................... 78
Dclaration d'une procdure......................................................................................................................78
Entte....................................................................................................................................................78
Variables locales...................................................................................................................................79
criture d'un appel de procdure.............................................................................................................. 79
Excution d'un appel de procdure...........................................................................................................80
Principe du retour la procdure appelante....................................................................................... 80
Passage des paramtres et excution de l'appel................................................................................80
Dclaration et appel de fonctions................................................................................................................... 81
Dclaration d'une fonction......................................................................................................................... 81
Appel de fonction.......................................................................................................................................81
Diffrences avec un appel de procdure.............................................................................................82
Les fonctions prdfinies...........................................................................................................................82
Expressions et appels de fonctions.......................................................................................................... 84
Exercices...............................................................................................................................................................84
Les tableaux...............................................................................................................................................................85
But de ce chapitre................................................................................................................................................ 85
Les tableaux une dimension............................................................................................................................. 85
Exemple introductif..........................................................................................................................................85
Le cas gnral................................................................................................................................................ 87
Utilisation de constantes pour dfinir la dimension d'un tableau................................................................... 88
Tableaux remplis partiellement............................................................................................................................. 89
Reprsentation................................................................................................................................................ 89
Adjonction d'une valeur...................................................................................................................................90
Adjonction la fin......................................................................................................................................90
Insertion......................................................................................................................................................90
Suppression d'un lment...............................................................................................................................91
Suppression du dernier lment............................................................................................................... 91
Suppression d'un lment quelconque (diffrent du dernier)................................................................... 91
Notion de pile.................................................................................................................................................. 92
Les tableaux deux dimensions......................................................................................................................... 92
Dclaration en Pascal..................................................................................................................................... 92
Traitement de tous les lments.................................................................................................................... 93
Traitement d'une ligne.....................................................................................................................................93
Traitement d'une colonne................................................................................................................................93
Exercices...............................................................................................................................................................94
Structures de contrle................................................................................................................................................94
But de ce chapitre................................................................................................................................................ 94
Les expressions logiques..................................................................................................................................... 95
Variable boolenne..........................................................................................................................................95
Oprateurs logiques........................................................................................................................................ 95
La ngation................................................................................................................................................ 96
La conjonction............................................................................................................................................96
La disjonction............................................................................................................................................. 97
Expressions logiques...................................................................................................................................... 97
Les variables boolennes..........................................................................................................................97
Les bases de la programmation par Eric Thirion
- 5 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Utilisation des oprateurs logiques........................................................................................................... 98
Utilisation des oprateurs de comparaison............................................................................................... 98
Les six oprateurs................................................................................................................................98
Comparaison d'expressions numriques............................................................................................. 98
Comparaison de chanes de caractres.............................................................................................. 99
Exercices......................................................................................................................................................... 99
La conditionnelle...................................................................................................................................................99
Le If................................................................................................................................................................. 99
Le If Then............................................................................................................................................. 99
Le If Then Else.............................................................................................................................. 100
If imbriqus.............................................................................................................................................. 101
L'instruction Exit....................................................................................................................................... 101
Case.............................................................................................................................................................. 102
Exercices....................................................................................................................................................... 103
Les boucles.........................................................................................................................................................103
Les boucles While.........................................................................................................................................103
Vocabulaire associ aux boucles............................................................................................................ 103
Droulement de la boucle....................................................................................................................... 104
Les boucles Repeat...................................................................................................................................... 105
Les boucles For............................................................................................................................................ 105
Exercices....................................................................................................................................................... 106
Corrigs des exercices....................................................................................................................................... 106
Les types structurs.................................................................................................................................................107
Introduction......................................................................................................................................................... 107
Les types structurs........................................................................................................................................... 107
Gnralits indpendantes du langage de programmation..........................................................................107
Dclaration.....................................................................................................................................................107
Dclaration d'un type structur................................................................................................................107
Dclaration de variables de type structur............................................................................................. 107
Manipulation des champs d'une structure.................................................................................................... 108
Dfinition de types complexes par combinaison.......................................................................................... 108
Tableaux de structures : les tables..........................................................................................................108
Structure avec champs de type structur............................................................................................... 108
Les pointeurs...................................................................................................................................................... 109
Dclaration d'un pointeur.............................................................................................................................. 109
Allocation dynamique de mmoire................................................................................................................110
Listes simplement chanes............................................................................................................................... 111
Reprsentation.............................................................................................................................................. 111
Parcours........................................................................................................................................................ 112
Adjonction d'un lment................................................................................................................................112
En dbut de liste..................................................................................................................................... 112
Insertion aprs un lment......................................................................................................................113
Suppression d'un lment.............................................................................................................................113
Suppression du premier lment............................................................................................................ 113
Suppression du suivant........................................................................................................................... 114
Listes doublement chanes...............................................................................................................................114
Reprsentation.............................................................................................................................................. 114
Adjonction d'un lment................................................................................................................................115
En dbut de liste..................................................................................................................................... 115
Insertion aprs un lment......................................................................................................................115
Exercices.............................................................................................................................................................115
Les fichiers............................................................................................................................................................... 116
But de ce chapitre.............................................................................................................................................. 116
Notion de fichier................................................................................................................................................. 116
Qu'est-ce qu'un fichier ?............................................................................................................................... 116
Nom de fichier...............................................................................................................................................116
Chemin d'accs............................................................................................................................................. 117
Identification d'un fichier par son nom complet............................................................................................ 117
Les bases de la programmation par Eric Thirion
- 6 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Format........................................................................................................................................................... 117
Les fichiers texte........................................................................................................................................... 118
Les fichiers structurs................................................................................................................................... 118
Oprations sur les fichiers................................................................................................................................. 118
Les erreurs d'accs.......................................................................................................................................118
Ouverture et fermeture d'un fichier...............................................................................................................119
quoi sert l'ouverture d'un fichier ?........................................................................................................119
quoi sert la fermeture d'un fichier ?..................................................................................................... 119
Accs direct et accs squentiel.................................................................................................................. 120
Accs direct............................................................................................................................................. 120
Accs squentiel......................................................................................................................................120
Manipulation des fichiers texte..................................................................................................................... 121
Ouverture d'un fichier texte..................................................................................................................... 121
Oprations sur les lignes.........................................................................................................................122
Manipulation des fichiers structurs............................................................................................................. 122
Ouverture d'un fichier structur............................................................................................................... 122
Accs squentiel......................................................................................................................................122
Accs direct............................................................................................................................................. 122
Manipulation de fichiers texte en Pascal........................................................................................................... 122
Dclaration.....................................................................................................................................................122
Assignation.................................................................................................................................................... 122
Cration d'un fichier texte............................................................................................................................. 123
Ouverture en criture...............................................................................................................................123
criture d'une ligne.................................................................................................................................. 123
Lecture d'un fichier texte...............................................................................................................................123
Ouverture d'un fichier texte en lecture.................................................................................................... 123
Lecture d'une ligne et test de fin de fichier.............................................................................................124
Les fichier structurs en Pascal.........................................................................................................................124
Dclaration.....................................................................................................................................................124
Assignation.................................................................................................................................................... 125
Ouverture et fermeture..................................................................................................................................125
criture squentielle......................................................................................................................................125
Lecture squentielle...................................................................................................................................... 126
Lecture jusqu'en fin de fichier................................................................................................................. 127
Exercices.............................................................................................................................................................127
Les bases de la programmation par Eric Thirion
- 7 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
propos de l'auteur
Eric Thirion, titulaire d'un doctorat en informatique et d'un Capes de mathmatiques, a pass plusieurs annes
l'tranger (de 1990 1994 l'Universit Heriot-Watt d'dimbourg, puis de 1994 1996 l'universit de Leuven en
Belgique) dans le cadre de contrats de recherche en vision par ordinateur.
Auteur d'une vingtaine de publications, il a enseign la programmation l'cole des Mines de Nancy, l'IUT de Nancy
et l'universit Louis Pasteur de Strasbourg.
Actuellement, il est professeur d'informatique en BTS-SIO l'cole Estudia de Strasbourg.
Note de la rdaction de Developpez.com
La relecture des diffrentes parties du cours a t ralise par Cdric DUPREZ, Claude Leloup, f-leb et Philippe
DUVAL.
Premires notions de programmation
But de ce chapitre
Dans ce cours, j'ai tout d'abord rassembl les notions qui m'ont sembl utiles introduire avant de commencer
proprement dit le cours de programmation.
En particulier, comme la programmation est conditionne par la manire dont fonctionne un ordinateur, il m'a sembl
logique de commencer par une prsentation trs sommaire de cette machine : sa structure, son fonctionnement, et
du seul langage qu'elle est capable de comprendre : le langage machine.
J'aborde ensuite les principes d'interaction homme-machine via une souris, un clavier et un cran graphique. Cela me
permet d'introduire la programmation vnementielle, avant de parler de l'environnement de dveloppement intgr
Lazarus, spcialement conu pour ce type de programmation.
Les bases de la programmation par Eric Thirion
- 8 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le cours de programmation proprement dit porte sur les instructions permettant de rentrer des donnes dans la
mmoire d'un ordinateur (la lecture, l'affectation) ou d'afficher des informations l'cran, ce qui demande au pralable
d'introduire les notions de variables, de type et d'expressions.
Un peu d'histoire
De la machine de Turing UML, retrouvez les moments-cls de l'histoire de l'informatique dans cette srie de slides :
tlchargez le document Projo-Histoire.pdf.
L'ordinateur
Un ordinateur est une machine utilisant et produisant de l'information. Il reoit de l'information (de l'utilisateur, par
internet), donne de l'information (informations affiches l'cran, imprimes), mmorise de l'information (en
mmoire vive, sur disque dur, cl USB, CD, DVD) et traite de l'information (calcul mathmatique, raisonnement
logique).
Nous allons donc commencer par parler de l'information et plus exactement de la manire dont elle est reprsente
dans un ordinateur.
Codage binaire
Le bit
Toute information traite par un ordinateur est code en binaire, c'est--dire par une suite de bits valant zro ou un.
La reprsentation physique du zro et du un dpend du type de support utilis : mmoire vive, disque dur, cl USB,
CD, etc. Mais, quel que soit le type de support utilis, il s'agit toujours d'un point de vue logique, d'une suite de zros
et de uns.
Le transistor
Pour prendre un exemple, la reprsentation physique actuelle d'un bit en mmoire vive est un transistor compos
de silicium. La reprsentation du zro et du un est base sur la rpartition des charges ngative et positive dans
le transistor.
Voici par exemple le zro :
Les bases de la programmation par Eric Thirion
- 9 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Et voici le un :
De 1970 2008, le nombre de transistors sur une puce lectronique a augment de manire vertigineuse en suivant
la loi de Moore : le nombre de transistors par puce double tous les deux ans pour le mme prix de fabrication. Les
transistors deviennent donc de plus en plus petits.
Les bases de la programmation par Eric Thirion
- 10 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Comme un signal lectrique met moins de temps parcourir une distance plus courte, cette progression a des
rpercussions directes sur la vitesse des processeurs (elle double tous les 18 mois). Elle entrane galement une
augmentation constante de la capacit des mmoires vives (la RAM des PC double tous les deux ans environ).
En 2008, la taille minimale d'un transistor tait de l'ordre de 45 milliardimes de mtre.
L'octet et autres units
Une suite de huit bits est appele un octet (ou byte en anglais). C'est l'unit de base permettant de dfinir la dimension
d'un espace de stockage. Il en drive des units plus grandes comme :
le kilooctet (ko = 210 octets = 1 024 octets) ;
le mgaoctet (Mo = 1 024 Ko, soit environ un million d'octets) ;
le gigaoctet (1 024 Mo, soit environ un milliard d'octets) ;
le traoctet (1 024 Go, soit environ mille milliards d'octets).
La mmoire vive des ordinateurs actuels (2013) est de l'ordre de plusieurs gigaoctets alors que la capacit des
disques durs se compte en traoctets.
La manire de coder une information en binaire dpend du type d'information. Les informations numriques, par
exemple, ne sont pas codes de la mme manire que le texte ou que les images ou le son.
Pour fixer les ides, voyons deux exemples de codage.
Le codage des nombres entiers en base 2
Le codage binaire des nombres entiers est bas sur l'criture des nombres en base 2 (en utilisant uniquement les
chiffres 0 et 1).
Les bases de la programmation par Eric Thirion
- 11 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le principe est le mme que celui de l'criture d'un nombre entier en base 10. c'est--dire l'criture habituelle d'un
nombre utilisant les 10 chiffres de 0 9. Rappelons que dans ce systme, chaque chiffre est associ une puissance
de 10. Il y a un chiffre pour les units (10
0
), un chiffre pour les dizaines (10
1
), un pour les centaines (10
2
), un pour
les milliers (10
3
), etc. Par exemple, 2013 signifie : 2 10
3
+ 0 10
2
+ 1 10
1
+ 3 10
0
.
L'criture d'un nombre entier en base 2 utilise le mme principe, sauf que les puissances de 10 sont remplaces par
des puissances de 2. Le nombre 40, s'crira par exemple : 101000. Car 40 = 32 + 8 ou autrement dit 2
5
+ 2
3
et donc
40 = 1 2
5
+ 0 2
4
+ 1 2
3
+ 0 2
2
+ 0 2
1
+ 0 2
0
.
Comme 40 n'a que six chiffres en base 2, on peut reprsenter ce nombre sur un octet comme suit :
Ce codage permet de coder de grands nombres en utilisant trs peu de bits :
jusqu' 64 000 environ avec 2 octets pour les entiers non signs (32 000 avec signe) ;
jusqu' 4 milliards environ avec 4 octets pour les entiers non signs (2 milliards avec signe).
Le codage du texte en ASCII
Les informations textuelles (suite de caractres) sont souvent codes en ASCII. Dans ce codage, chaque caractre
est reprsent par un octet de valeur prdfinie dans une table de correspondance.
La valeur est en fait l'interprtation du codage binaire de l'octet en nombre entier, comme nous l'avons vu au
paragraphe prcdent.
Prenons par exemple, le caractre ( . Dans la table de correspondance ASCII, on voit que sa valeur est 40.
Autrement dit, le codage binaire du caractre ( est :
c'est--dire le mme codage que celui du nombre 40 sur un octet !
Mais alors comment un ordinateur peut-il distinguer un nombre d'un caractre ?
Il ne le peut pas !
En effet, la simple connaissance d'une suite de 0 et de 1 ne permet pas de savoir ce que reprsente cette suite. Tout
dpend de la manire dont elle est interprte.
Si on donne l'octet prcdent un ordinateur, il y verra le nombre 40, si ce moment-l il s'attend un nombre et
il y verra le caractre ( , si ce moment-l, il s'attend un caractre.
Les bases de la programmation par Eric Thirion
- 12 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Mmoire vive et adresse
Barrette de RAM DDR3 de 4 Go
La mmoire vive (ou RAM pour Random Access Memory) d'un ordinateur peut tre vue comme une suite continue
d'octets.
Chaque octet possde un numro. Le numro du premier est 0, du deuxime 1, etc. Ce numro s'appelle l'adresse
de l'octet.
Une plage mmoire est une suite d'octets conscutifs. Elle peut donc tre dfinie par une plage d'adresses (adresses
minimale et maximale) ou bien par l'adresse de dbut (ou autrement dit, l'adresse minimale) de la zone et du nombre
d'octets qu'elle contient.
Voici, par exemple, une plage mmoire de trois octets, dmarrant l'adresse 2 :
Langage machine et programme excutable
Processeur Intel 80486DX2 (taille: 12 6,75 mm)
Le processeur d'un ordinateur excute en permanence des instructions que l'on appelle instructions machine. Il
contient (en outre) des mmoires de petite taille (quelques octets), appeles registres, qui servent transfrer des
donnes de la mmoire vers le processeur (ou inversement) en vue d'effectuer des oprations sur ces donnes.
Une instruction machine est un ordre donn au processeur.
Les bases de la programmation par Eric Thirion
- 13 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Par exemple :
copier une plage mmoire d'adresse donne dans un registre ;
copier le contenu d'un registre dans une plage mmoire d'adresse donne ;
additionner, soustraire, diviser ou multiplier les nombres contenus dans deux registres et enregistrer le
rsultat dans un troisime registre.
Nous avons vu plus haut que toute information traite par un ordinateur est code en binaire. Il en de mme des
instructions machine. Une instruction machine est code en binaire sur quelques octets (4 ou 8 dans les machines
actuelles). Une partie du codage dfinit le type d'opration effectuer et une autre, les objets (les registres, par
exemple) sur lesquels cette opration doit agir.
La manire de coder les instructions machine dpend du type de processeur.
On appelle langage machine l'ensemble de conventions dfinissant le codage binaire des
instructions machine d'un type particulier de processeur.
Une suite d'instructions machine constitue un programme ou plus prcisment un programme
excutable.
Il est important de noter que le langage machine est le seul langage directement excutable par un ordinateur. Les
langages de programmation (comme C, Java, PHP) ne le sont pas !
Les programmes excutables peuvent se trouver en mmoire (on dit qu'ils sont rsidents) ou sur le disque, sous
la forme de fichiers (reconnaissables sous Windows par leur extension .exe). Mais pour pouvoir tre excuts, ils
doivent forcment tre chargs en mmoire :
Les bases de la programmation par Eric Thirion
- 14 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Nous avons dit plus haut qu'un programme excutable est une suite d'instructions.
En fait, pour tre plus exact, il faudrait dfinir un programme excutable comme un mlange de zones de code
contenant des instructions machine et de zones de donnes servant stocker provisoirement les informations
traites (donnes ou rsultats).
Processus
La mmoire d'un ordinateur contient plusieurs programmes que le processeur excute tour de rle une telle
vitesse que l'on a l'impression qu'ils sont excuts en mme temps.
Chacun de ces programmes rsidents possde donc ses propres zones d'instructions et de donnes.
Les bases de la programmation par Eric Thirion
- 15 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
L'excution d'un programme particulier par un ordinateur s'appelle un processus.
Notez qu'un mme programme peut donner lieu plusieurs processus.
Parmi les processus rsidents figurent ncessairement les processus systme, qui servent (entre autres) grer
les priphriques (clavier, souris, cran, disque, lecteur de CD, imprimantes, etc.) et les fichiers.
Les entres-sorties
Jusqu' prsent, nous avons essentiellement dcrit l'ordinateur du point de vue du processeur et de la mmoire vive.
Le processeur excute en permanence des programmes chargs en mmoire. Ces programmes sont des suites
d'instructions machine et de plages mmoire rserves aux donnes.
Mais si les instructions excutes par le processeur ne font que transfrer des informations entre la mmoire vive et
les registres, comment peut-il communiquer avec le clavier ? Avec la souris ? Avec l'cran ?
Comment les plages mmoire rserves aux donnes peuvent-elles recevoir les donnes de l'utilisateur ?
Comment peuvent-elles s'afficher l'cran ?
Pour rpondre ces questions, il nous faut tout d'abord complter notre vision d'un ordinateur et considrer les
lments externes l'unit centrale que l'on appelle les priphriques (cran, clavier, souris, disque, lecteur de CD,
cl USB, imprimante, etc.).
Les priphriques ont leurs propres circuits spcialiss appels interfaces d'entres-sorties. Pour l'cran, par
exemple, il s'agit de la carte graphique. Ces circuits peuvent avoir leurs propres registres, leur propre mmoire et
mme leurs propres processeurs.
Ils communiquent avec le processeur et la mmoire par un ensemble de fils que l'on appelle le bus de donnes.
Les bases de la programmation par Eric Thirion
- 16 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
En ralit, les instructions excutes par le processeur ne se limitent pas la mmoire centrale. Certaines
instructions spciales, appeles instructions d'entre-sortie, permettent de transfrer des donnes entre les
interfaces d'entre-sortie et les registres du processeur ou directement avec la mmoire vive.
Ceci explique trs sommairement comment se fait la communication entre le processeur et les priphriques
et indirectement, comment un programme peut envoyer des informations vers un priphrique ou recevoir des
informations provenant d'un priphrique.
Mais cela n'explique pas l'interaction avec l'utilisateur. En effet, vous remarquerez que votre ordinateur ragit
instantanment (ou quasiment) lorsque vous jectez un CD, introduisez une cl USB, bougez la souris, appuyez sur
une touche du clavier, etc.
Ces actions physiques de l'utilisateur sur l'ordinateur peuvent se produire n'importe quel moment, alors que le
processeur est occup excuter les instructions machine d'un programme quelconque. Or c'est ncessairement
le processeur qui doit ragir ces actions.
Il faut donc qu'il soit capable d'interrompre l'excution du programme en cours pour ragir immdiatement n'importe
quelle action de l'utilisateur.
Comment cela est-il possible ?
Les interruptions
La rponse cette question se trouve dans le mcanisme d'interruption.
Une interruption (physique) est un signal envoy au processeur par un dispositif externe
l'unit centrale.
Le clavier va par exemple envoyer un signal d'interruption au processeur chaque fois qu'une touche est appuye. La
souris envoie une interruption chaque fois qu'elle est dplace ou que l'utilisateur effectue un clic.
Le processeur possde des entres spcialement prvues pour recevoir ces signaux.
Lorsqu'il reoit une interruption, il interrompt provisoirement le programme qu'il est en train d'excuter pour excuter
des instructions du systme d'exploitation prvues, pour traiter ce type d'interruption. Il existe par exemple des
instructions prvues pour traiter les interruptions clavier, d'autres pour traiter des interruptions souris, etc.
Les bases de la programmation par Eric Thirion
- 17 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le systme ne gre pas entirement les interruptions ; elles sont sous-traites par les pilotes (drivers en anglais)
des priphriques. Un pilote est un programme spcialis dans la gestion d'un priphrique spcifique. Il ne fait pas
partie du systme d'exploitation, car il est gnralement produit par le fabricant du priphrique.
Une fois l'interruption traite, le processeur reprendra ce qu'il tait en train de faire l'endroit exact o il s'tait arrt.
Pour donner une image, on pourrait comparer ce mcanisme au rflexe humain. Prenons par exemple une personne
lisant un livre. Le cerveau de cette personne joue le rle du processeur. Le programme excut est la lecture du
livre. Soudain, une abeille pique la personne. La douleur perue est le signal d'interruption envoy au cerveau (le
processeur). Par rflexe, la personne lche le livre. C'est une raction prprogramme dans l'inconscient (le systme
d'exploitation). Aprs avoir soign la piqre (traitement de l'interruption), la personne reprend la lecture du livre
l'endroit o elle s'tait arrte.
Les Interfaces graphiques
Historique
Les premires interfaces graphiques sont apparues avec l'invention de la souris (1967) et des crans graphiques,
c'est--dire capables d'afficher des images.
Avant cela, les crans d'ordinateur n'affichaient que du texte et ressemblaient plutt ceci :
Les bases de la programmation par Eric Thirion
- 18 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
En 1973 apparat le premier ordinateur avec interface graphique : la station graphique Xerox Alto fabrique en
Californie, Palo Alto, par la socit Xerox (par ailleurs l'origine de la machine photocopier).
La station Xerox Alto
Les bases de la programmation par Eric Thirion
- 19 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
En 1983, cet ordinateur a inspir le premier PC de Apple, le LISA, anctre des Macintosh puis en 1985, le premier
systme Windows (Windows 1.0) de Microsoft.
Le Lisa
C'est ainsi que sont apparus les premiers systmes d'exploitation munis d'interfaces graphiques, dans lesquelles les
applications apparaissent sous forme de fentres ou d'icnes sur lesquelles on peut agir grce la souris.
Interface du systme
De manire gnrale, l'interface graphique d'un programme est la manire dont il se prsente visuellement l'cran
lorsqu'il s'excute.
Dans cette partie, nous dcrivons plus particulirement l'interface graphique du systme qui apparat au dmarrage
d'un ordinateur. Dans Windows, par exemple, elle est constitue du bureau et d'une barre de tches.
Le bureau contient des icnes de diffrents programmes. La barre des tches donne accs (entre autres) au menu
Dmarrer, par l'intermdiaire duquel on peut accder diffrents composants du systme, configurer l'ordinateur,
arrter l'ordinateur, etc.
Tout ceci constitue l'interface graphique du systme d'exploitation.
Les bases de la programmation par Eric Thirion
- 20 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le curseur
On voit galement apparatre le curseur, qui se prsente gnralement sous la forme d'une petite flche. Le curseur
permet d'indiquer sur quel lment de l'interface graphique on veut agir.
Lorsque l'utilisateur dplace la souris, il provoque une interruption gre par le systme d'exploitation. Le traitement
par dfaut de cette interruption consiste dplacer le curseur.
Gestion du clic
Comme nous l'avons vu, un clic provoque une interruption, qui est tout d'abord intercepte par le systme
d'exploitation. Le traitement de cette interruption dpendra de la position du curseur. Nous reviendrons l-dessus
plus en dtail un peu plus loin.
Lorsque l'on clique sur l'icne d'un programme, par exemple, le systme le charge en mmoire et lance son excution.
L'interface graphique de ce programme s'affiche alors l'cran.
Fentre d'une application
L'interface graphique d'un programme se prsente gnralement sous la forme d'un rectangle, appel fentre, dans
lequel apparaissent des composants ou contrles. Les composants sont par exemple des menus, des barres
d'outils, des zones de texte
Voici par exemple une partie de l'interface graphique d'Excel 2003 :
Les zones de texte sont des zones rectangulaires de l'cran dans lesquelles il est possible de taper du texte sur une
ligne. Nous reviendrons plus en dtail sur ce composant graphique.
un moment donn, l'cran contient une (ou plusieurs) fentre(s) pour chaque application ouverte. Par exemple,
une fentre pour Internet Explorer, une fentre pour Word, une autre pour Photoshop, etc. Mais parmi toutes ces
fentres, il y a une seule fentre active : c'est la fentre qui apparat au premier plan et qui contient le curseur.
Les bases de la programmation par Eric Thirion
- 21 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les vnements
Lorsqu'il se produit une interruption souris (dplacement de la souris ou clic) ou clavier (touche appuye ou relche),
il y a deux possibilits :
1 Il n'y a aucune fentre active. Dans ce cas, l'interruption est directement gre par le systme. Sous
Windows, c'est par exemple le cas lorsque vous cliquez sur le bureau ;
2 Il y a une fentre active. Dans ce cas, le systme intercepte tout d'abord l'interruption, mais il ne la gre pas
forcment entirement. Une partie de la gestion de l'interruption est sous-traite l'application associe
cette fentre. Pour cela, il communique toutes les informations utiles l'application sous la forme d'un
vnement. Les parties d'une l'application qui interceptent les vnements et les grent sont appels des
gestionnaires d'vnements.
Un vnement est li un composant particulier de la fentre, que l'on pourrait appeler le composant actif : c'est
le composant contenant le curseur au moment de l'vnement.
Les bases de la programmation par Eric Thirion
- 22 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Une application pourra ainsi savoir sur quel composant l'utilisateur a cliqu ou quel tait le composant actif lorsqu'il
a appuy sur telle touche du clavier.
Les zones de texte
Les interfaces graphiques sont gnralement conues pour viter au maximum de taper du texte. Mais il arrive que
ce soit invitable. Par exemple, pour donner le nom d'un fichier, une adresse web, une recherche par mots-cls, etc.
Dans une interface graphique, la saisie de texte se fait par l'intermdiaire des zones de texte, zones rectangulaires
dans lesquelles il est possible de rentrer du texte.
Pour cela, l'utilisateur doit tout d'abord activer la zone de texte en cliquant dedans. Le curseur change alors de forme.
En gnral, il se transforme en une barre verticale clignotante, ce qui signifie que la zone de texte est active et prte
recevoir du texte.
Lorsqu'une zone de texte est active, les caractres frapps au clavier viennent s'afficher l'cran l'intrieur de
celle-ci. On a ainsi l'impression que les caractres sont directement transfrs du clavier vers l'cran. En ralit, ils
sont tout d'abord transfrs en mmoire par le systme d'exploitation.
En effet, chaque zone de texte est associe une plage mmoire, appele buffer, destine mmoriser les
caractres frapps.
Supposons qu'une zone de texte soit active et que l'utilisateur appuie sur la touche s . Le systme va alors
transfrer le caractre s dans le buffer associ cette zone de texte, puis dans un deuxime temps, afficher le
contenu du buffer l'cran l'intrieur de la zone de texte.
S'il appuie ensuite sur la touche t , le caractre t va tre rajout dans le buffer aprs le s , puis le buffer
va tre raffich.
Ce mcanisme est trs important, car c'est essentiellement de cette manire que des donnes sont communiques
un programme. Nous reviendrons l-dessus lorsque nous parlerons de la lecture des donnes.
La programmation
Les langages de programmation ont t introduits pour viter l'criture directe de programmes en langage machine
(tche extrmement fastidieuse, pour ne pas dire impossible !).
Les bases de la programmation par Eric Thirion
- 23 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Mais tout d'abord, qu'est-ce qu'un programme ?
Notion de programme
Un programme crit dans un langage de programmation se prsente sous la forme d'un texte
dans lequel figurent les instructions excuter. Dans ce texte, les plages mmoire contenant
des donnes portent un nom. Ce sont les variables du programme.
Voici par exemple une instruction crite en Pascal :
somme := x + y;
Cette instruction signifie : additionner les nombres contenus dans les variables x et y et stocker le rsultat dans la
variable somme.
Dans les cours de programmation, un programme est souvent dfini comme une suite d'instructions. Cette dfinition
n'est pas tout fait exacte, car les programmes contiennent galement des dclarations. Une dclaration permet
(entre autres) de dfinir la nature des variables sur lesquelles le programme doit travailler.
Voici par exemple une dclaration de variable crite en Pascal :
var x, y , somme : integer;
Ici le programmeur a dclar que les variables x, y et somme doivent contenir des nombres entiers.
Notion de langage
Un langage de programmation est un ensemble de conventions dfinissant la manire d'crire
un programme sous la forme d'un texte.
Ces conventions comprennent des conventions syntaxiques (comparables la grammaire d'une langue naturelle) et
lexicales (comparables l'orthographe d'une langue naturelle).
Elles sont videmment diffrentes d'un langage l'autre. Voici par exemple l'instruction d'addition vue plus haut
traduite dans diffrents langages de programmation :
Les bases de la programmation par Eric Thirion
- 24 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
On constate que dans certains langages (comme PHP et LISP), les dclarations de variables ne sont pas obligatoires.
Ces langages sont dits non typs.
Tous les langages de programmation possdent des mots spciaux, que l'on appelle des mots-cls (dans l'exemple
ci-dessus, ces mots figurent en gras). Les mots-cls ont une signification particulire prdfinie dans le langage de
programmation. Ils ne peuvent donc pas tre utiliss par le programmeur pour signifier autre chose.
En Pascal, par exemple, le mot-cl Integer signifie nombre entier.
Fichiers sources
Un programme crit dans un langage de programmation se prsente sous la forme d'un ou plusieurs fichiers appels
fichiers sources (par opposition aux fichiers excutables).
Ces fichiers contiennent les programmes tels qu'ils ont t initialement crits par les dveloppeurs. Ce sont des textes
crits en un langage de programmation particulier, que l'on peut visualiser l'aide d'un diteur de texte (WordPad,
par exemple).
Mais, comme nous l'avons dj dit plus haut, le seul langage de programmation directement excutable par un
ordinateur est le langage machine adapt son processeur.
Les fichiers sources doivent donc tre traduits en langage machine avant de pouvoir tre excuts. On appelle cela
la compilation. Mais nous verrons plus loin que la compilation n'est pas la seule approche possible : il en existe
une autre appele interprtation.
Compilation
Notion de compilateur
Certains langages, le C par exemple, ne peuvent tre que compils. Les langages de ce type sont appels langages
compils. Pour pouvoir les utiliser, vous devez avoir install sur votre ordinateur un compilateur spcifique ce
langage.
Le compilateur est un programme excutable qui permet de traduire un programme crit dans
un langage de programmation en langage machine.
Par exemple, pour pouvoir programmer en C, vous devez ncessairement avoir install un compilateur C sur votre
machine.
Les bases de la programmation par Eric Thirion
- 25 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Aprs avoir t compil, le programme peut tre excut en chargeant sa version excutable en mmoire :
Exemple de compilation
Pour fixer un peu les ides, reprenons le programme d'addition en Pascal et voyons comment il pourrait tre traduit
en langage machine.
Les variables dclares sont tout d'abord associes des plages mmoires :
Les bases de la programmation par Eric Thirion
- 26 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les instructions sont ensuite traduites en instructions machine portant sur les registres et les plages mmoire
associes aux variables :
Dans cet exemple, nous n'avons pas donn le code binaire des instructions machine, car il serait sans intrt. On
voit qu'une simple instruction crite en langage de programmation peut correspondre de nombreuses instructions
machine.
Interprtation
Les programmes crits en langages interprts (Java, Visual Basic, PHP) peuvent tre excuts sans avoir t
auparavant entirement traduits en langage machine.
Ils font appel un interprteur.
Tout comme un compilateur, un interprteur est spcifique un langage donn.
Il existe, par exemple, un interprteur Java, un interprteur Visual Basic, un interprteur PHP
Contrairement aux programmes compils, les programmes interprts ne sont pas directement excuts par
l'ordinateur, mais par l'interprteur (qui, lui, est excut par la machine !).
Pour excuter un programme interprt, il faut tout d'abord lancer l'interprteur, puis charger le code source du
programme en mmoire. Ce code source peut ensuite tre excut par l'interprteur :
Les bases de la programmation par Eric Thirion
- 27 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
L'interprteur s'excute donc toujours en mme temps que le programme interprt.
Notez que certains interprteurs (comme Visual Basic) peuvent galement fonctionner en tant que compilateur. Cela
permet d'obtenir une version plus rapide et commercialisable du programme, lorsque la mise au point est termine.
En effet :
l'excution d'un programme compil est beaucoup plus rapide que son interprtation ;
sous sa forme excutable, un programme peut tre vendu sans divulguer les fichiers sources, ainsi qu' des
utilisateurs ne possdant pas l'interprteur sur leur machine.
Les EDI
Le dveloppement d'application (ou si vous prfrez la programmation) se fait aujourd'hui grce des logiciels
appels EDI (pour Environnement de Dveloppement Intgr) ou IDE en anglais. Un EDI peut tre adapt un
langage de programmation particulier (Delphi, Lazarus pour le langage Pascal, Visual C++ pour le langage C++) ou
plusieurs langages (Eclipse pour Java, PHP, JavaScript).
Un EDI comprend en gnral un diteur de texte spcialement adapt au langage, un compilateur et/ou un
interprteur, un dbogueur (outil de mise au point) et, surtout, un outil de dveloppement d'interface graphique.
Les bases de la programmation par Eric Thirion
- 28 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Avant l'existence des EDI, la conception de l'interface graphique d'un programme tait extrmement fastidieuse, car
le dveloppeur devait lui-mme prciser dans le programme les positions et dimensions de tous les composants de
l'interface.
Avec un EDI cela se fait simplement en dessinant en quelque sorte l'interface graphique l'aide de la souris.
videmment, les instructions permettant d'afficher l'interface existent toujours, mais au lieu d'tre donnes par le
programmeur, elles sont gnres automatiquement par l'EDI.
La programmation vnementielle
Avec l'apparition des interfaces graphiques dans les annes 80, la programmation est devenue plus complexe. Les
programmes devaient d'une part produire tout le design de l'interface et d'autre part pouvoir ragir aux vnements,
c'est--dire aux actions de l'utilisateur sur les diffrents composants de cette interface.
Il est alors apparu une nouvelle manire de programmer, appele programmation vnementielle, qui consiste
associer des gestionnaires d'vnements aux composants de l'interface.
Un des premiers langages permettant la programmation vnementielle a t le langage Visual Basic de Alan Cooper
(premire version en 1991) et son environnement de dveloppement intgr (un des premiers galement). Le concept
a ensuite t repris par Borland avec Delphi.
Alan Cooper - inventeur du Visual Basic
Un des points les plus intressants des EDI est qu'ils facilitent la programmation vnementielle. Rappelons qu'avec
un EDI, l'interface graphique peut tre dessine par le programmeur. Il peut ensuite associer un gestionnaire
d'vnements (initialement vide) un composant de l'interface en cliquant sur celui-ci.
Les bases de la programmation par Eric Thirion
- 29 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Lazarus
Lazarus est un environnement de dveloppement intgr associ au langage Pascal Objet. C'est la version open
source du logiciel Delphi de Borland. Ce logiciel facilite en particulier la cration d'interfaces graphiques et la
programmation vnementielle par un mcanisme de gnration automatique de code.
Notion de formulaire
Sous Lazarus, une fentre s'appelle un formulaire.
Voici, par exemple, un formulaire ralis avec Lazarus :
Ce formulaire comporte trois tiquettes, trois zones de texte et un bouton.
Les bases de la programmation par Eric Thirion
- 30 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Nous avons vu que les zones de texte permettent l'utilisateur de saisir des donnes. En fait, elles servent galement
afficher des rsultats.
Dans notre exemple, les deux zones de texte tiquetes X et Y servent saisir les deux nombres additionner. Ce
sont les donnes du programme. La zone de texte tiquete X+Y sert afficher la somme de ces deux nombres.
C'est le rsultat du programme produit par l'ordinateur.
Les tiquettes servent donc en principe indiquer l'utilisateur quelle donne il doit introduire dans la zone de texte
situe juste ct ou bien quel rsultat y sera affich.
Lorsque l'utilisateur clique sur le bouton Additionner, aprs avoir saisi les deux nombres dans les zones de texte
prvues cet effet, le programme affiche le rsultat dans la zone de texte tiquete X+Y.
Un bouton sert donc dclencher un traitement d'information particulier (dans notre cas, l'addition de deux nombres).
Gnration automatique de code
La cration d'une nouvelle application engendre automatiquement la cration d'un formulaire (initialement vide)
associ un fichier source Pascal appel unit (Unit en anglais).
Les bases de la programmation par Eric Thirion
- 31 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le formulaire de dpart
Par dfaut, ce formulaire s'appelle Form1 et l'unit Pascal associe, Unit1. Si le dveloppeur ne la renomme pas
autrement, elle sera reprsente sur disque par le fichier Unit1.pas.
Ds la cration du formulaire, l'unit qui lui est associe contient du code Pascal gnr automatiquement.
Le voici :
Les bases de la programmation par Eric Thirion
- 32 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Au fur et mesure que le programmeur ajoute des composants sur le formulaire, leurs noms apparaissent
automatiquement dans le code source. Avec l'exemple prcdent du programme d'addition, ce serait Label1, Label2,
Label3 pour les tiquettes ; Edit1, Edit2, Edit3 pour les zones de texte ; Button1 pour le bouton.
Voici le code source de l'unit associe au programme d'addition, aprs que le programmeur a dpos les diffrents
composants sur le formulaire :
Les bases de la programmation par Eric Thirion
- 33 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Ces noms permettront d'accder aux composants par programme. Il ne faut pas les confondre avec leurs libells.
Les libells apparaissent sur l'interface graphique. Les noms quant eux sont invisibles.
Par exemple, le nom du bouton est Button1, mais son libell est Additionner.
Pour pouvoir plus facilement identifier les composants dans le programme, le dveloppeur peut leur donner des
noms plus significatifs que ceux gnrs automatiquement par Lazarus. Par exemple, BoutonAdditionner au lieu
de Button1 pour le bouton, ZoneTexteX et ZoneTexteY pour les zones de texte contenant les deux nombres
additionner, ZoneTexteSomme pour la zone de texte contenant la somme des deux nombres.
La modification des noms des composants se fait via l'interface graphique de Lazarus. Ils sont alors automatiquement
modifis dans le code.
Voici le code modifi automatiquement aprs modification des noms :
Les bases de la programmation par Eric Thirion
- 34 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Programmation vnementielle
L'interface graphique de Lazarus est conue pour faciliter la programmation vnementielle.
Rappelons que la programmation vnementielle consiste associer des gestionnaires d'vnements des
vnements de l'interface graphique. Un vnement est dfini par un composant de l'interface et un type
d'interruption. Par exemple, un bouton (composant) et un clic sur ce bouton (interruption). Lorsque cet vnement a
effectivement lieu, les instructions contenues dans le gestionnaire d'vnements sont automatiquement excutes.
Sous Lazarus, un gestionnaire d'vnements s'appelle une procdure vnementielle.
Pour associer une procdure vnementielle un composant, le dveloppeur n'a besoin de taper aucune ligne de
code. Il lui suffit en gros de cliquer sur le composant et ventuellement de slectionner le type d'interruption. Un
double-clic sur un composant slectionne l'interruption par dfaut. La dclaration de la procdure vnementielle
est alors automatiquement gnre dans le code avec un nom form partir du nom du composant et du nom de
l'interruption.
Reprenons l'exemple de notre programme d'addition.
Supposons que le dveloppeur souhaite associer une procdure vnementielle au bouton Additionner, qui serait
active lorsque l'utilisateur clique sur ce bouton.
Les bases de la programmation par Eric Thirion
- 35 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Pour cela, il lui suffit de faire un double-clic sur ce bouton et la dclaration de cette procdure vnementielle sera
automatiquement gnre dans le code source, avec aucune instruction l'intrieur.
Le nom de cette procdure est BoutonAdditionnerClick. Il est form partir du nom du composant (ici
BoutonAdditionner) et du nom de l'interruption (Click = clic de souris).
Le dveloppeur compltera ensuite ce gestionnaire d'vnements en plaant des instructions l'intrieur (entre begin
et end), qui seront automatiquement excutes lorsque l'utilisateur cliquera sur ce bouton.
Ordre d'excution des instructions
En gnral, un programme ne s'excute pas dans l'ordre des lignes du code source, c'est--dire de la premire
la dernire ligne du fichier.
Considrons un programme dont l'interface graphique possde trois boutons A, B et C :
Dans le code source, on a d'abord la procdure vnementielle du bouton B, puis celle du bouton A, puis celle du
bouton C. Mais l'ordre d'excution de ces procdures est totalement indpendant de l'ordre dans lequel elles figurent
dans le fichier source. Cela dpend videmment de l'ordre dans lequel l'utilisateur cliquera sur les boutons A, B et
C. Une mme procdure peut mme tre excute plusieurs fois.
Lorsqu'une procdure vnementielle a fini de s'excuter, le programme retourne dans un tat d'attente d'vnement.
Notice d'utilisation
Tlchargez ici la notice d'utilisation de Lazarus.
Les bases de la programmation par Eric Thirion
- 36 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les variables
La notion de variable
La notion de variable existe dans tous les langages de programmation.
Les variables servent conserver temporairement des donnes en mmoire.
Une variable peut tre vue comme une plage mmoire dans une zone de donnes d'un
programme. Elle porte un nom et possde un instant donn une valeur.
On peut donc parler de l'adresse d'une variable : c'est l'adresse du dbut la plage mmoire qui lui est rserve.
Voici par exemple quatre variables nommes Age, Nom, NombreEnfant et Prenom.
La valeur d'une variable varie lors de l'excution d'un programme (d'o le nom de variable justement !). La variable
NombreEnfant pourra par exemple valoir successivement 2, 0, 3, 1, 0, 4
Par contre, le nom d'une variable ne change pas : il est le mme du dbut la fin de l'excution d'un programme.
Les noms de variables en Pascal
En Pascal, les noms de variables doivent respecter les rgles suivantes :
Rgle1 : le premier caractre est obligatoirement une lettre ;
Rgle2 : les seuls caractres autoriss sont les lettres (sans accents), les chiffres et _ ;
Rgle3 : un nom de variable ne peut pas tre un mot-cl du langage.
Voici quelques exemples et contre-exemples de nom de variables :
Nom Validit Rgles non respectes
Prenom Oui
Prnom Non 2
Nom101 Oui
Nom_Eleve Oui
Nom Eleve Non 2
_Age Non 1
Age-Eleve Non 2
Integer Non 3
Les bases de la programmation par Eric Thirion
- 37 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Attention : la casse n'a pas d'importance, c'est--dire que le Pascal ne distingue pas les
minuscules des majuscules. Nom_Eleve, nom_Eleve, nom_eleve dsignent donc la mme
variable.
La notion de type
Il existe diffrents types de variables.
Le type d'une variable dfinit la manire dont elle est reprsente en mmoire et les oprations
que l'on peut faire dessus.
Il existe, par exemple, des variables de type chane de caractres, qui vont servir stocker du texte en mmoire.
La variable Prenom pourrait, par exemple, tre de ce type. un instant donn, sa valeur pourrait tre 'Astrix',
un autre moment 'Oblix' ou encore un autre moment 'Abraracourcix'.
Il existe aussi des variables de type entier. Ce pourrait, par exemple, tre les variables Age, ou NombreEnfant.
La reprsentation en mmoire d'une variable dpend de son de type. En particulier, deux variables de types distincts
n'occupent pas en gnral la mme place mmoire :
D'autre part, les oprations que l'on peut faire sur deux variables de types diffrents ne sont pas les mmes. Par
exemple, on ne pourra pas multiplier deux chanes de caractres, alors que l'on peut trs bien multiplier deux entiers.
Les bases de la programmation par Eric Thirion
- 38 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Dclaration d'une variable
La dclaration d'une variable sert dfinir son type et, par consquent, la manire dont elle
sera reprsente en mmoire. Elle a pour effet de rserver une plage mmoire pour stocker
la valeur de cette variable. Le type de la variable dfinit la taille de cette plage et la manire
de coder ses valeurs.
Toute variable doit (en principe) tre dclare, avant de pouvoir tre utilise. En Pascal, la dclaration est
obligatoire. D'autres langages (comme Visual Basic) autorisent une dclaration implicite avec un type par dfaut.
Malheureusement, cela autorise galement des erreurs de programmation
La manire de dclarer une variable dpend videmment du langage de programmation, mais on y trouve toujours
les mmes ingrdients : le nom de la variable et son type.
Dclaration d'une variable en Pascal
Syntaxe gnrale
Une dclaration de variable en Pascal utilise le mot-cl Var suivi du nom de la variable, du caractre : , puis du
nom du type et d'un point-virgule.
Var Nom de la variable : nom du type ;
Dclaration d'un entier
Prenons par exemple la variable Age.
En Pascal, le type entier s'appelle Integer. La dclaration de la variable Age se ferait donc comme ceci :
Var Age : Integer ;
Le type double
Les nombres entiers ne sont pas les seuls nombres avec lesquels un ordinateur peut calculer. Il y a galement les
nombres dcimaux (comme 0.5 ou 3.14 par exemple). Ces nombres peuvent par exemple (il y a d'autres possibilits)
tre reprsents par le type Double en Pascal.
Dclaration d'une chane de caractres
Prenons par exemple la variable Prenom, de type chane de caractres.
En Pascal, le type chane de caractres s'appelle String. La dclaration de la variable Prenom s'crira donc :
Var Prenom : String ;
Regroupement des dclarations
Remarquez qu'il est inutile de rpter le mot-cl var. De plus, les variables de mme type peuvent tre regroupes :
on spare les noms des variables par des virgules puis on prcise leur type par : nom du type ;
Exemple :
Les bases de la programmation par Eric Thirion
- 39 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Var Nom, Prenom : String ; Age, NombreEnfant : Integer;
O faut-il dclarer les variables ?
Pour qu'une variable soit utilisable n'importe quel endroit d'une unit Pascal, elle doit tre dclare entre var et
implementation, comme dans l'exemple suivant :
var
Form1: TForm1;
// Dclaration des variables globales
x, y , somme : integer;
implementation
Nous avons dclar ici trois variables de type entier : x, y et somme.
Les variables dclares de cette manire sont appeles variables globales. Cela signifie qu'elles peuvent tre
utilises dans tout le code du fichier o elles sont dclares.
Lecture et affichage
Donnes et rsultats d'un traitement
De nombreux traitements informatiques peuvent se schmatiser suivant les trois tapes suivantes :
L'image du sourd-muet qui ne sait pas additionner
Pour bien comprendre le sens des termes lecture, traitement et affichage, mettez-vous la place de l'ordinateur.
Votre rle est d'additionner mentalement deux nombres pour un sourd-muet qui ne sait pas calculer (l'utilisateur).
Comme il ne peut pas parler, il vous crit les deux nombres additionner sur un bout de papier, qui joue le rle
de l'cran.
Vous ne pouvez pas additionner les deux nombres si vous ne les connaissez pas. Il faut donc commencer par les
lire. C'est la premire tape de lecture des donnes.
prsent, les deux nombres additionner sont dans votre mmoire. Vous pouvez donc effectuer le traitement, qui
consiste additionner mentalement ces deux nombres. C'est l'tape de traitement des donnes.
Vous avez le rsultat. Mais si vous ne le communiquez pas l'utilisateur, c'est comme si vous n'aviez rien fait. Comme
il est sourd, vous allez crire le rsultat sur le bout de papier. C'est la troisime tape : l'affichage des rsultats
du traitement.
Pour un ordinateur
Pour un ordinateur c'est un peu la mme chose :
Les bases de la programmation par Eric Thirion
- 40 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
1 Lire les donnes signifie transfrer des informations affiches l'cran vers la mmoire, ou plus prcisment
vers une variable-donne, c'est--dire une variable prvue pour stocker une donne du traitement.
2 Traiter les donnes signifie grosso modo faire des calculs qui dpendent des donnes pour produire des
rsultats. En principe, mais ce n'est pas obligatoire, chaque rsultat est stock dans une variable-rsultat.
La programmation de cette tape sera vue plus loin dans le cours lorsque nous parlerons d'expression et
d'affectation.
3 Si les rsultats ont t sauvegards dans des variables-rsultats, Afficher les rsultats signifie afficher la
valeur de chacune de ces variables l'cran. Il est galement possible d'afficher les rsultats d'un traitement
sans les avoir au pralable sauvegards dans des variables. Mais il serait difficile pour l'instant d'expliquer
comment. Nous verrons cela un peu plus loin.
Exemple du programme d'addition
Reprenons l'exemple de l'addition de deux nombres.
Lire les donnes signifierait dans ce cas lire les valeurs des deux nombres additionner depuis (par exemple) deux
zones de texte pour les stocker dans deux variables donnes X et Y.
Les bases de la programmation par Eric Thirion
- 41 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Traiter les donnes signifierait additionner les valeurs des variables X et Y, puis mmoriser le rsultat dans une
variable Somme.
Enfin, afficher les rsultats signifierait afficher la valeur de la variable somme dans la zone de texte prvue cet effet.
Historique
Avant l'apparition des interfaces graphiques, tous les langages de programmation avaient des procdures (cette
notion sera aborde dans le chapitre sous-programmes) pour lire et afficher.
En Pascal, par exemple, elles s'appellent readln (pour la lecture) et writeln (pour l'criture).
Les bases de la programmation par Eric Thirion
- 42 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
La procdure writeln
La procdure writeln vous permettait d'afficher un texte l'cran. Par exemple l'instruction :
writeln ('Hello world !');
vous affichait le texte Hello Word l'cran, comme ceci (en supposant que l'cran tait vide avant l'excution
de l'instruction) :
Avec la procdure writeln, vous pouviez galement afficher la valeur d'une variable l'cran. Par exemple, en
supposant que la variable Somme contienne la valeur 2013, l'instruction :
writeln (Somme);
vous affichait 2013 l'cran, comme ceci :
Les bases de la programmation par Eric Thirion
- 43 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Chaque writeln affichait donc une nouvelle ligne la suite des lignes dj affiches l'cran.
La procdure readln
La procdure readln permettait de lire la valeur d'une variable tape au clavier (et donc affiche l'cran).
Supposons par exemple qu'un programme excute l'instruction suivante :
readln (X);
o X reprsente un nombre entier.
Ds que l'instruction est excute, le programme est momentanment interrompu. Le systme d'exploitation prend
alors la main et range chaque caractre saisi par l'utilisateur dans un buffer associ au clavier. Ds que l'utilisateur
appuie sur la touche Entre, le contenu du buffer est renvoy au programme qui stocke alors la valeur correspondante
dans la variable X et continue son excution.
ETBib
ETBib est une unit Pascal que j'ai crite afin d'introduire des procdures quivalentes readln et writeln
fonctionnant avec une interface graphique.
Ces procdures sont les suivantes :
Lire, LireEntier et LireNombre : pour lire une variable depuis une zone de texte ;
Afficher, AfficherEntier, et AfficherNombre : pour afficher une variable dans une zone de texte ou une
zone de liste ;
Effacer : pour effacer le contenu d'une zone texte ou d'une zone de liste.
Ces procdures ont t introduites pour des raisons pdagogiques (explications pour le lecteur averti). Donc
gardez bien l'esprit qu'elles ne font pas partie du langage Pascal.
Exemple d'utilisation des procdures de ETBib
Pour expliquer le fonctionnement des procdures de ETBib, nous allons prendre un exemple de programme qui
permet de lire et d'afficher trois variables :
Ville, de type String, est destine contenir le nom d'une ville. Sa valeur sera lue et affiche dans la zone de
texte ZT_Ville ;
CP, de type integer, pour le code postal de la ville, lue et affiche dans la zone de texte ZT_CodePostal ;
NH, de type double, pour le nombre d'habitants de la ville exprim en milliers. Remarquez que ce
nombre n'est pas forcment entier : 264,2 reprsente par exemple 264 200 habitants. La zone de texte
correspondante se nomme ZT_Hab.
Voici l'interface graphique du programme :
Les bases de la programmation par Eric Thirion
- 44 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Lecture des variables
La lecture des trois variables est dclenche par le bouton Lire. Voici la procdure vnementielle associe :
procedure TForm1.BT_LireClick(Sender: TObject);
begin
Lire (Ville,ZT_Ville);
LireEntier (CP, ZT_CodePostal);
LireNombre (NH,ZT_Hab);
end;
La procdure de lecture utiliser dpend du type de la variable : Lire pour lire une variable de type String, LireEntier
pour lire une variable de type Integer et LireNombre pour lire une variable de type Double.
Entre parenthses figurent :
en premire position : le nom de la variable lire ;
en deuxime position : le nom de la zone de texte.
Rappelez-vous que chaque zone de texte est associe un buffer, qui se remplit avec les caractres frapps au
clavier.
Lorsque la variable est de type chane de caractres, la procdure de lecture ne fait que recopier ces caractres
dans la variable.
S'il s'agit d'une variable de type Integer ou Double, il ne suffit pas de recopier le buffer dans la variable. Le contenu
du buffer est tout d'abord cod en base 2, puis c'est le rsultat de ce codage qui est stock dans la variable.
Affichage des variables
L'affichage des trois variables se fait par le bouton Afficher, dont voici la procdure vnementielle :
procedure TForm1.BT_AfficherClick(Sender: TObject);
begin
Afficher (Ville, ZT_Ville);
AfficherEntier (CP, ZT_CodePostal);
AfficherNombre (NH, ZT_Hab);
end;
Les bases de la programmation par Eric Thirion
- 45 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Comme pour la lecture, il faut choisir la procdure d'affichage en fonction du type de la variable : Afficher pour
afficher une variable de type String, AfficherEntier pour une variable de type integer et AfficherNombre pour une
variable de type Double.
Dans les parenthses, on prcise le nom de la variable afficher, puis le nom de la zone de texte dans laquelle
on souhaite l'afficher.
La procdure Afficher recopie simplement le contenu de la variable dans le buffer, qui est ensuite affich dans la
zone de texte par le systme d'exploitation.
Dans le cas des procdures AfficherNombre et AfficherEntier, un dcodage pralable est ncessaire avant de
recopier la chane de caractres reprsentant le nombre dans le buffer.
Effacement des zones de texte
L'effacement des zones de texte s'effectue avec le bouton Effacer, dont voici la procdure vnementielle :
procedure TForm1.BT_EffacerClick(Sender: TObject);
begin
Effacer (ZT_Ville); Effacer (ZT_Hab);
Effacer (ZT_CodePostal);
end;
Il suffit ici de prciser entre parenthses le nom de la zone de texte effacer.
Argumentation pdagogique
Cette section s'adresse au lecteur averti (professeur ou lve avanc) dsirant comprendre la raison pour laquelle
j'ai introduit les procdures de lecture et d'affichage.
Reprenons notre exemple. Voici comment lire les trois variables sans utiliser les procdures Lire, LireEntier et
LireNombre :
procedure TForm1.BT_LireClick(Sender: TObject);
begin
Ville := ZT_Ville.Text;
CP := StrToInt(ZT_CodePostal.Text);
NH := StrToFloat (ZT_Hab.Text);
end;
Ce qui me gne ici est l'utilisation obligatoire de la programmation objet. On accde l'attribut Text de la classe TEdit.
C'est encore pire lorsqu'il s'agit d'afficher du texte dans une zone de liste, puisqu'il faut alors appliquer la mthode
Add l'attribut items (objet de la classe TStringList) d'un objet de la classe TListBox.
Or, je pense que l'on peut difficilement commencer un cours de programmation avec des notions de programmation
objet. mon sens, la programmation objet ne peut tre aborde qu'aprs avoir bien assimil les types structurs
(puisque les objets sont en quelque sorte des types structurs tendus) et les sous-programmes (puisque les
mthodes sont des sous-programmes associs des classes).
Mis part la programmation objet, d'autres arguments peuvent tre ajouts en faveur de l'utilisation des procdures
de lecture et d'affichage :
cela rend le code plus lisible ;
cela oblige les lves programmer plus proprement : les donnes doivent obligatoirement tre transfres
dans des variables avant d'tre utilises. On ne travaille pas directement sur les zones de texte pour faire des
calculs ;
Les bases de la programmation par Eric Thirion
- 46 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
on voit mieux la diffrence entre une lecture (ou un affichage) et une simple affectation.
Les expressions
Vous connaissez dj tous les expressions mathmatiques dans lesquelles on retrouve des nombres, des oprateurs
de calculs (+, -, etc.) et des variables. Par exemple :
(a + b) (a - 17)
Dans les langages de programmation, on retrouve galement cette notion d'expression sous une forme un peu
diffrente et plus gnrale.
Une expression est une criture possdant une valeur et un type, dans laquelle figurent (entre
autres) des littraux, des constantes, des oprateurs et des noms de variables.
Vous savez dj ce que sont les variables. Par contre, nous n'avons pas encore dfini les littraux, les constantes
et les oprateurs.
La valeur d'une expression est le rsultat du calcul de cette expression, en tenant compte des valeurs des variables
qu'elle contient. Son type est le type du rsultat.
L'criture Age+1, est, par exemple, une expression de type entier, car :
la variable Age est de type entier ;
1 est un entier ;
la somme de deux entiers est un entier.
Sa valeur est celle de la variable Age augmente de 1.
Une expression peut faire intervenir plusieurs oprations. Par exemple :
(Age + 1) * 2
reprsente le double de la valeur de la variable Age augmente de 1.
Voil diffrentes valeurs des expressions Age+1 et (Age+1)*2 pour diffrentes valeurs de la variable Age :
Age Age+1 (Age + 1) * 2
10 11 22
0 1 2
43 44 88
Les littraux
Un littral est l'criture d'une valeur d'un certain type de variable.
L'criture des littraux obit un certain nombre de conventions qui dpendent du type et du langage de
programmation.
Les bases de la programmation par Eric Thirion
- 47 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les littraux numriques
Un littral numrique reprsente la valeur d'un nombre.
Il existe de nombreuses manires d'crire un nombre. On peut par exemple avoir :
une simple suite de chiffres. Cette criture ne convient que pour les nombres entiers positifs. Exemple :
2012 ;
pour pouvoir reprsenter des entiers relatifs, il faut autoriser la prsence d'un signe + ou - devant cette suite
de chiffres. Exemple : -15, +320 ;
pour pouvoir reprsenter des nombres non entiers, on utilise le point. La partie entire du nombre est suivie
d'un point puis d'une autre suite de chiffres. Exemples : 3.141559, -5.33333 ;
pour pouvoir reprsenter des nombres trs grands ou trs petits, on autorise galement la notation
scientifique. Exemple : 1.7E+308.
Les littraux chanes de caractres
Un littral de type chane de caractres s'crit entre quotes.
Par exemple : 'Il fait beau', '4012', '(3 x + 1)', 'VisualC++', '@%^' sont des littraux de type chane de caractres.
On remarquera que tous les caractres sont autoriss entre les quotes sauf les quotes eux-mmes ! Pour mettre une
quote dans une chane de caractres, il faut la faire prcder par une autre quote. Par exemple :
L''horaire d''t'
Parmi les chanes de caractres, il y en a une qui joue un rle particulier : la chane vide.
La chane vide est une chane qui ne contient aucun caractre. On l'crit '' (deux quotes).
Les constantes
Une constante est un littral portant un nom. Avant la compilation (ou l'interprtation) du code,
ce nom sera remplac par le littral dans tout le code.
Une constante est donc en quelque sorte le synonyme d'une valeur. On pourra par exemple introduire une constante
PI reprsentant le nombre 3.14159. Avant la compilation du code (cette tape s'appelle en fait la prcompilation),
toutes les occurrences du mot PI seront remplaces par 3.14159.
Comme son nom l'indique, la valeur d'une constante ne peut pas varier durant l'excution d'un programme.
Dclaration d'une constante en Pascal
En Pascal, une constante peut se dclarer de la manire suivante :
Const nom de constante = littral ;
Le nom d'une constante obit aux mmes rgles que le nom d'une variable.
Exemple :
Les bases de la programmation par Eric Thirion
- 48 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Const PI = 3.14159 ;
CLEF_USB = 'F:' ; DISQUE_DUR = 'C:';
Oprateur
En informatique, un oprateur est gnralement reprsent par un ou deux caractres reprsentant une certaine
opration.
Voici, par exemple, quelques oprateurs frquemment rencontrs dans les langages de programmation : + - / *
^ = ++ ! %
Dans ce cours, nous nous concentrerons pour l'instant sur les oprateurs suivants :
l'oprateur d'addition, reprsente par le caractre + ;
l'oprateur de soustraction,reprsent par le caractre - ;
l'oprateur de multiplication, reprsent par le caractre * (et non pas comme en mathmatique !) ;
L'oprateur de division, reprsent par le caractre / ;
l'oprateur de concatnation, reprsent par le caractre +.
Vous connaissez dj les quatre premiers oprateurs, puisqu'il s'agit des oprateurs mathmatiques classiques. Mais
si vous n'avez jamais fait de programmation, vous ignorez probablement le sens de l'oprateur de concatnation.
La concatnation
Concatner deux chanes de caractres signifie les mettre bout bout.
Par exemple, si je concatne la chane 'para' avec la chane 'pluie', j'obtiens la chane 'parapluie'.
La manire de noter l'oprateur de concatnation dpend des langages.
En Pascal, il se note comme l'oprateur d'addition, c'est--dire avec un signe +.
L'oprateur de concatnation permet de construire des expressions de type chane de caractres.
Par exemple, 'Je suis '+Prenom est une expression de type chane de caractres constitue d'un littral ('Je suis
'), de l'oprateur de concatnation + et d'un nom de variable (Prenom).
On peut concatner autant de chanes de caractres qu'on le souhaite. Par exemple, dans l'expression 'Je suis
'+Prenom+' '+Nom il y a quatre chanes de caractres.
Voil diffrentes valeurs de l'expression
'Je suis ' + Prenom
pour diffrentes valeurs de la variable Prenom :
Prenom 'Je suis '+Prenom
'Jimi' 'Je suis Jimi'
'Albert' 'Je suis Albert'
Voil diffrentes valeurs de l'expression
Les bases de la programmation par Eric Thirion
- 49 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
'Je suis ' + Prenom + ' ' + Nom
pour diffrentes valeurs des variables Prenom et Nom :
Prenom Nom 'Je suis '+Prenom+' '+Nom
'Jimi' 'Hendrix' 'Je suis Jimi Hendrix'
'Albert' 'Einstein' 'Je suis Albert Einstein'
'Albert' '' 'Je suis Albert'
Validit d'une expression
L'criture d'une expression dans un certain langage de programmation doit ncessairement obir aux rgles propres
ce langage.
Une expression de type T est valide si elle peut tre comprise par l'interprteur (ou
le compilateur) comme un calcul d'une valeur de type T ou plus gnralement comme la
construction d'un objet de type T.
Nous donnons ici, un certain nombre de rgles non exhaustives permettant d'crire des expressions valides en
Pascal.
Expressions valides de type chane de caractres
Les rgles suivantes permettent de construire des expressions de type chane de caractres valides :
Rgle1 : un nom de variable est une expression valide si et seulement cette variable est de
type chane de caractres ;
Rgle2 : un littral (ou une constante reprsentant ce littral) est une expression valide si et
seulement si il est du type chane de caractres ;
Rgle3 : A+B est valide si et seulement si A et B sont deux expressions valides de type chane
de caractres ;
Rgle4 : un littral, une constante ou un nom de variable ne pas tre suivi immdiatement d'un
littral, d'une constante ou d'un nom de variable.
Exemples d'application de ces rgles (Nom et Prenom sont des chanes de caractres et Age est un entier) :
Les bases de la programmation par Eric Thirion
- 50 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Expression Validit Rgle non respecte
Prenom Oui
Age Non 1
'Thirion' Oui
48 Non 2
'Eric'+'Thirion' Oui
Prenom+Nom Oui
Prenom+'Thirion' Oui
'Cours de'+Prenom+'Thirion' Oui
'Eric'+'Thirion a' +Age+' ans' Non 3
'Eric'+'Thirion a' + 48 +' ans' Non 3
Prenom Nom Non 4
'Eric' 'Thirion' Non 4
Prenom 'Thirion' Non 4
Expressions valides de type numrique
Les rgles suivantes (non exhaustives) permettent de construire des expressions numriques valides :
Rgle1 : une variable est une expression numrique valide si et seulement si elle est de type
numrique (integer ou double par exemple) ;
Rgle2 : un littral (ou une constante reprsentant ce littral) est une expression numrique
valide si et seulement si il est de type numrique ;
Rgle3 : les critures A+B, A-B, A*B, A/B sont des expressions numriques valides si et
seulement si A et B sont des expressions numriques valides ;
Rgle4 : un littral, une constante ou un nom de variable ne peut pas tre suivi immdiatement
d'un littral, d'une constante ou d'un nom de variable ;
Rgle5 : (A) est une expression numrique valide si et seulement si A est une expression
numrique valide ;
Rgle6 : chaque parenthse ouvrante correspond une et une seule parenthse fermante.
Exemples d'application de ces rgles (avec Nom de type String, Age de type Integer et Poids de type Double) :
Les bases de la programmation par Eric Thirion
- 51 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Expression Validit Rgle non respecte
Nom Non 1
Age Oui
201 Oui
20.14 Oui
'20.14' Non 2
Age * Poids Oui
Age + Nom Non 3
Poids/(Age*2.2) Oui
Age Poids Non 4
Age 49 Non 4
(Age * Poids) Oui
(Age * Nom) Non 5
(Poids/((Age*(2.2))) Oui
Poids/((Age + 1 ) Non 6
Affichage d'expression
Les procdures d'affichage de l'unit ETBib permettent d'afficher la valeur d'une expression. Selon le type de
l'expression, on utilisera Afficher, AfficherEntier ou AfficherNombre.
Expression de type chane de caractres
Pour afficher une expression E de type chane de caractres dans une zone de texte ou zone de liste Z, on utilisera
l'instruction :
Afficher ( E, Z);
Exemple : la variable Nom contient le nom d'une personne et la variable Adresse son adresse. L'instruction suivante
permet d'afficher le nom et l'adresse de la personne sur une seule ligne dans la zone de liste ZL_Client :
Afficher (Nom + '-' + Adresse, ZL_Client);
Le nom et l'adresse sont spars par un tiret.
Expression numrique
Pour une expression numrique dont le rsultat est toujours un nombre entier, on peut utiliser AfficherEntier ou
AfficherNombre. Par contre, si le rsultat n'est pas forcment entier, il faudra utiliser AfficherNombre.
Exemple 1 : un htel propose des chambres 47 euros. La variable NJ contient le nombre de jours. L'instruction
suivante permet d'afficher le prix du sjour dans la zone de texte ZT_PrixSejour :
AfficherEntier ( NJ * 47 , ZT_PrixSejour);
Dans cet exemple, on peut utiliser la procdure AfficherEntier, car le prix payer est forcment un nombre entier.
Exemple 2 : supposons prsent que le prix d'une chambre soit variable et pas forcment entier. Ce prix est stock
dans une variable P de type double. Dans ce cas, on ne sait pas si le prix du sjour est un nombre entier. Il faut
donc utiliser l'instruction :
Les bases de la programmation par Eric Thirion
- 52 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
AfficherNombre ( NJ * P , ZT_PrixSejour);
Traitement sans variables-rsultats
Revenons sur le schma lecture-traitement-affichage. prsent, nous pouvons expliquer comment afficher les
rsultats d'un traitement sans les sauvegarder dans des variables : il suffit d'crire l'expression du traitement
l'intrieur de l'instruction d'affichage !
Voil par exemple comment crire le programme d'addition sans sauvegarder le rsultat dans une variable :
var
Form1: TForm1;
// Dclaration des variables globales
x, y : integer;
implementation
{ TForm1 }
procedure TForm1.BoutonAdditionnerClick(Sender: TObject);
begin
// Lecture des donnes
LireEntier (x,zoneTexteX);
LireEntier (y,ZoneTexteY);
// Traitement et Affichage du rsultat
AfficherEntier (x + y, ZoneTexteSomme);
end;
Le calcul de l'addition se fait l'intrieur de l'instruction d'affichage.
Dans des cas simples, cette manire de programmer peut tre utilise. Mais de manire gnrale, essayez autant
que possible de sparer le traitement des donnes et l'affichage. Vous obtiendrez ainsi des programmes plus lisibles
et plus faciles modifier.
L'affectation
L'affectation est une instruction qui permet de modifier la valeur d'une variable. Plus prcisment :
Affecter une valeur une variable signifie enregistrer cette valeur dans la plage mmoire
alloue cette variable.
Affecter une valeur une variable modifie donc l'tat de la zone mmoire qui lui est alloue, ou autrement dit son
contenu .
Reprenons notre exemple avec les quatre variables Age, NombreEnfant, Nom et Prenom. Supposons qu' un
instant donn l'tat de la mmoire soit le suivant :
Les bases de la programmation par Eric Thirion
- 53 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Si on affecte ensuite la valeur 33 la variable Age, on obtient :
Et la zone mmoire alloue la variable Age restera inchange jusqu' ce qu'une valeur diffrente lui soit affecte.
criture d'une instruction d'affectation en Pascal
En Pascal, on reprsente l'affectation par l'oprateur :=. Le nom de la variable figure gauche de := et la valeur
qu'on veut lui affecter, droite.
Par exemple, affecter la valeur 33 la variable Age s'crira :
Age := 33 ;
De manire gnrale, ce qui figure droite de := est une expression. Une affectation s'crit donc sous la forme :
Nom de variable := expression ;
Une affectation est toujours excute de droite gauche. c'est--dire que l'expression figurant droite du signe :=
est d'abord value et que sa valeur est ensuite enregistre dans la variable dont le nom figure gauche du :=.
Exemple de code Pascal avec des affectations
Voil un premier exemple de code Pascal, principalement compos d'affectations :
Var Age, MonAge : Integer;
begin
Age := 20 ;
MonAge := 47 ;
Age := Age+1 ;
Age := Age*2 ;
MonAge := Age ;
end;
Ce code commence par la dclaration de deux variables de type entier (Age et MonAge). Aprs la partie dclaration,
on a cinq instructions d'affectation.
Voil comment se droule l'excution de ce code :
Aprs l'excution
de l'instruction
Age vaut MonAge vaut
Age := 20 ; 20 ?
MonAge := 47 ; 20 47
Age := Age + 1 ; 21 47
Age := 2 * Age ; 42 47
MonAge := Age ; 42 42
Les bases de la programmation par Eric Thirion
- 54 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Remarque : la premire valeur de la variable MonAge est indtermine. Tant que l'on n'a pas
affect de valeur une variable, on ne sait pas ce qu'elle contient.
Affectation rcursive
Dans une affectation, l'expression affecte la variable peut elle-mme contenir la variable. On dit alors que
l'affectation est rcursive.
Exemple 1
Ajouter le prix d'un article au prix total, se traduit par l'affectation rcursive suivante :
PrixTotal := PrixTotal + Prix ;
Exemple 2
Augmenter une variable de 1, se dit incrmenter. C'est un cas particulier d'affectation rcursive trs frquemment
utilis en programmation.
Par exemple, pour incrmenter le nombre d'articles :
NombreArticle := NombreArticle + 1 ;
Traitement itratif
Les affectations rcursives sont en gnral utilises dans des traitements itratifs, c'est--dire des traitements que
l'on rpte plusieurs fois. Chaque rptition d'un traitement itratif s'appelle une itration.
Illustrons ceci par un exemple.
Considrons un programme permettant de calculer la dure totale des morceaux d'un album. Voici son interface
graphique :
Les bases de la programmation par Eric Thirion
- 55 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le bouton Ajouter ajoute le nouveau titre saisi dans la zone de liste et augmente la dure totale de l'album par la
dure de ce morceau.
Nous avons ici un exemple de traitement itratif, puisque les mmes oprations vont tre effectues chaque fois que
l'utilisateur ajoute un album. Ou autrement dit, chaque fois qu'il clique sur le bouton Ajouter.
Voici, le code de la procdure vnementielle de ce bouton :
procedure TForm1.BT_AjouterClick(Sender: TObject);
begin
//--- Lecture des donnes
Lire (Titre, ZT_Titre);
LireEntier (Duree, ZT_Duree);
//--- Traitement des donnes
DureeT := DureeT + Duree;
Numero := Numero + 1;
//--- Affichage
AfficherEntier (Numero, ZL_Num);
Afficher (Titre, ZL_Titre);
AfficherEntier (Duree, ZL_Duree);
AfficherEntier (DureeT, ZT_DureeT);
end;
Le traitement consiste :
lire le titre du morceau et sa dure ;
augmenter la dure totale (DureeT) par la dure du morceau ;
incrmenter le numro du morceau ;
afficher le numro, le titre et la dure du morceau dans les zones de liste prvues cet effet ;
Les bases de la programmation par Eric Thirion
- 56 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
afficher la dure totale.
Mais que vaut la dure totale au dpart ? Quel est le numro du premier morceau ?
Cela dpend de la valeur de ces variables avant la premire itration, c'est--dire au dmarrage du programme.
Il faudrait donc pouvoir affecter des valeurs de dpart (on dit initialiser) aux variables DureeT et Numero. Sinon,
on ne pourra pas connatre leur valeur initiale.
Mais avec ce que nous avons vu jusqu' prsent, nous n'avons aucun moyen de faire excuter des instructions
l'ordinateur avant le premier clic sur un bouton.
Heureusement, il existe une procdure vnementielle qui est appele ds le dmarrage du programme. Elle
s'appelle Form_Create. Pour l'ajouter au code, il suffit de double-cliquer sur le fond du formulaire.
C'est donc dans la procdure Form_Create, qu'il faut initialiser les variables.
Voici la procdure Form_Create de notre exemple :
procedure TForm1.FormCreate(Sender: TObject);
begin
//--- Initialisation
DureeT := 0;
Numero := 0;
end;
Comme cette procdure est dclenche ds le dmarrage du programme, nous saurons que la dure totale et le
numro seront nuls avant la premire itration.
Exemple et conseils
L'objectif de la programmation n'est pas seulement de faire des programmes qui marchent.
En ralit, un programme n'est jamais termin (du moins un programme volumineux tel que vous en rencontrerez en
entreprise). Il faut donc pouvoir le modifier facilement, sachant que le dveloppeur qui sera charg de la mise jour
de votre programme ne sera pas forcment vous-mme. Cela a deux consquences :
1 Votre code doit tre lisible, c'est--dire qu'en le lisant on devine facilement ce qu'il fait. ;
2 D'autre part, il doit tre facilement modifiable.
Dans cette partie du cours, je vous donne travers un exemple quelques conseils permettant de rendre un programme
plus lisible et plus facile modifier.
Mises part la lisibilit et la facilit de modification, il existe d'autres critres importants en programmation que nous
n'aborderons pas ici :
la rapidit d'excution du code. Cet aspect est le sujet essentiel de l'algorithmique, qui peut tre vue
comme la science de rsoudre un problme par un programme de manire ce que ce programme s'excute
le plus rapidement possible. Sachez simplement que la manire de programmer peut jouer normment sur
la vitesse d'excution ;
la concision du code, c'est--dire la rsolution d'un problme avec un programme le plus court possible.
Certains programmeurs sont capables d'crire en deux lignes ce que d'autres crivent en vingt lignes. Cet
aspect est mon avis moins important que les autres dans la mesure o un code concis est souvent peu
lisible.
Les bases de la programmation par Eric Thirion
- 57 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Exemple de programme et conseil
Cahier des charges
La ralisation d'un projet informatique dmarre en gnral avec un cahier des charges. C'est en gros une description
de ce que devrait faire le logiciel.
Voici le cahier des charges de notre exemple :
On souhaiterait crire un programme qui calcule la surface peindre dans une pice rectangulaire possdant des
portes et des fentres.
Pour simplifier, on supposera que les murs ont 2m50 de hauteur et que toutes les fentres ont la mme dimension
(1.4 1.2) et de mme pour les portes (0.9 2.1).
Dclaration des constantes
Introduisons une constante pour chaque donne fixe du problme :
const
LargeurFenetre = 1.4;
HauteurFenetre = 1.2;
LargeurPorte = 0.9;
HauteurPorte = 2.1;
HauteurMur = 2.5;
On pourrait se passer de ces dclarations et mettre directement les valeurs 1.4, 1.2, etc. dans les calculs, mais on
obtiendrait ainsi un code moins lisible et plus difficile mettre jour.
S'il faut corriger la hauteur des portes par exemple, il suffit de changer la valeur de la constante et cette modification
sera automatiquement rpercute dans tout le code (dans tous les calculs o la hauteur des portes intervient).
Essayez de procder de cette manire ds que vous avez des valeurs fixes. Dclarez des
constantes au lieu d'crire les valeurs dans les instructions.
Conception de l'interface graphique
La surface peindre dpendra donc de la taille de la pice ainsi que du nombre de portes et de fentres. Ce seront
les donnes du programme. On en dduit l'interface graphique suivante :
Les bases de la programmation par Eric Thirion
- 58 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les zones de texte sont nommes ZT_Largeur (largeur de la pice), ZT_Longueur (longueur de la pice), ZT_NF
(nombre de fentres), ZT_NP (nombre de portes) et ZT_SP (surface peindre).
Les noms des zones de texte sont tous prfixs par ZT_. Cette manire de procder permet d'viter des conflits avec
des noms de variables. En programmation, un mme nom ne peut dsigner qu'une seule chose. Vous ne pouvez
pas, par exemple, nommer une zone de texte Largeur et utiliser par ailleurs une variable de mme nom. Je vous
propose de prfixer les noms des zones de texte par ZT_, ceux des zones de liste par ZL_ et ceux des boutons par
BT_. Vous pouvez bien sr avoir vos propres conventions. L'essentiel est d'en avoir une.
Lecture et dclaration des donnes
Associons une variable chaque donne : LargeurPiece, LongueurPiece, NFenetre et NPorte. D'o les
dclarations :
Var LargeurPiece, LongueurPiece : Double;
NFenetre, NPorte : Integer;
Je n'ai pas besoin de vous expliquer ici la signification de chaque variable, car les noms choisis
permettent de deviner la fonction de chacune d'entre elles. Pour obtenir un code lisible, il est
recommand de procder de cette manire : utilisez des noms de variables parlants. Cette
remarque est videmment galement valable pour les noms de constantes et pour, de manire
gnrale, n'importe quel nom utilis dans un programme.
Nous pouvons prsent crire les instructions de lecture de donnes dans la procdure vnementielle du bouton
Calculer :
procedure TForm1.BT_CalculClick(Sender: TObject);
begin
// Lecture des donnes
LireNombre (LargeurPiece, ZT_Largeur);
LireNombre (LongueurPiece, ZT_Longueur);
LireEntier (NFenetre, ZT_NF);
LireEntier (NPorte, ZT_NP);
end;
Les bases de la programmation par Eric Thirion
- 59 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Traitement, rsultats intermdiaires et finals
Il nous faut maintenant rflchir la manire de calculer la surface peindre. Pour simplifier le problme, nous allons
le dcouper le traitement en plusieurs tapes :
1 Calcul de la surface des murs ;
2 Calcul de la surface des fentres ;
3 Calcul de la surface des portes ;
4 Calcul de la surface peindre.
Le rsultat de chaque tape sera sauvegard dans une variable : SurfaceDesMurs, SurfaceDesFenetres,
SurfaceDesPortes, SurfacePeinture.
Essayez galement de procder de cette manire lorsque vous avez un calcul compliqu.
Dcoupez le calcul en plusieurs parties et sauvegardez le rsultat de chacun de ces calculs
dans une variable. la fin, crivez le calcul du rsultat final en utilisant les rsultats des calculs
intermdiaires. Cette manire de programmer simplifie la rsolution du problme et rend le
programme plus lisible.
Il nous faut d'abord dclarer les nouvelles variables :
Var LargeurPiece, LongueurPiece : Double;
NFenetre, NPorte : Integer;
SurfaceDesMurs, SurfaceDesPortes, SurfaceDesFenetres,
SurfacePeinture : double;
Vous pouvez galement procder de cette manire. Il est en gnral difficile de prvoir ds
le dbut toutes les variables que l'on aura besoin d'utiliser dans un programme. Ajoutez vos
dclarations de variable au fur et mesure des besoins.
crivons prsent les quatre tapes de calcul.
Calcul de la surface des quatre murs :
SurfaceDesMurs :=
2 * (LargeurPiece+LongueurPiece) * HauteurMur;
Calcul de la surface des fentres :
SurfaceDesFenetres :=
NFenetre * LargeurFenetre * HauteurFenetre;
Calcul de la surface des portes :
SurfaceDesPortes :=
NPorte * LargeurPorte * HauteurPorte;
Calcul de la surface peindre :
SurfacePeinture :=
SurfaceDesMurs - SurfaceDesFenetres - SurfaceDesPortes;
Le code de la procdure en entier
Pour conclure, voici le code de la procdure vnementielle du bouton Calculer :
Les bases de la programmation par Eric Thirion
- 60 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
procedure TForm1.BT_CalculClick(Sender: TObject);
begin
//--- Lecture des donnes

LireNombre (LargeurPiece, ZT_Largeur);
LireNombre (LongueurPiece, ZT_Longueur);
LireEntier (NFenetre, ZT_NF);
LireEntier (NPorte, ZT_NP);

//--- Traitement des donnes
SurfaceDesMurs :=
2 * (LargeurPiece+LongueurPiece) * HauteurMur;
SurfaceDesFenetres :=
NFenetre * LargeurFenetre * HauteurFenetre;
SurfaceDesPortes :=
NPorte * LargeurPorte * HauteurPorte;
SurfacePeinture :=
SurfaceDesMurs - SurfaceDesFenetres - SurfaceDesPortes;
// Affichage des rsultats

AfficherNombre (SurfacePeinture,ZT_SP);
end;
Le code de cette procdure est bien spar en trois parties : lecture des donnes, traitement
des donnes, puis affichage des rsultats. Essayez galement de procder de cette manire.
crivez votre code en sparant bien la lecture, le traitement et l'affichage.
Synthse
Voici un rsum de tous les conseils vus prcdemment.
Lorsque vous avez des valeurs fixes, utilisez des constantes.
Prfixez les noms des composants de l'interface graphique (suggestion : ZT_ = zone de
texte, ZL_ = zone de liste, BT_ = bouton).
Utilisez des noms parlants.
Lorsque vous avez un calcul (ou plus gnralement un traitement) compliqu, dcoupez-
le en plusieurs parties et sauvegardez les rsultats de chaque partie dans des variables.
Sparez bien la lecture des donnes, le traitement des donnes et l'affichage des rsultats.
Exercices
Retrouvez diffrents exercices sur le site de l'auteur :

recherches complmentaires sur internet ;

prise en main de Lazarus ;

programme sans interface graphique ;

exercices de programmation ;

exercices complmentaires ;

exercices thoriques.
Pour obtenir les corrigs, le tlchargement n'est possible que via un login et un mot de passe, que vous pouvez
obtenir en envoyant un mail l'adresse suivante :
Les bases de la programmation par Eric Thirion
- 61 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
en prcisant un peu qui vous tes et les raisons pour lesquelles ce cours vous intresse.
Sous-programmes
But de ce chapitre
Les sous-programmes existent dans tous les langages de programmation, depuis les origines. En effet, les
dveloppeurs se sont vite rendu compte que dans la programmation on retrouve trs souvent des traitements
similaires. Avec les sous-programmes, il devient possible de regrouper ces traitements en un seul bout de code
rutilisable, ce qui permet une conomie de temps considrable. D'autre part, l'utilisation de sous-programmes rend
le code plus lisible et plus facile mettre jour. C'est donc une bonne manire de programmer.
Dans ce chapitre, nous verrons comment crire et utiliser des sous-programmes. Nous verrons galement qu'il est
possible de dclarer des variables l'intrieur d'un sous-programme et que ces variables, appeles variables locales,
se diffrencient subtilement des variables globales que nous avons dj rencontres dans le premier cours.
Introduction
Le but de la programmation n'est pas seulement de faire des programmes qui marchent. Ils doivent galement tre
lisibles, faciles mettre jour et plus concis.
C'est essentiellement cela que servent les sous-programmes.
Dcoupage d'un programme en sous-programmes
crire du code l'aide de sous-programmes est avant tout une manire de programmer : au lieu de concevoir un
programme en un seul bloc, on le dcoupe en plusieurs parties aussi indpendantes que possible. Chacune de ces
parties porte un nom : ce sont les sous-programmes.
Bien entendu, cette manire de programmer n'est pas obligatoire. On peut trs bien programmer sans jamais crire
de sous-programmes, mais cela donne des programmes trs longs, peu lisibles et difficiles mettre jour.
Par analogie, on pourrait comparer ceci au dcoupage d'une entreprise en plusieurs services. Chaque service
ayant un rle particulier jouer dans l'entreprise. De mme, on peut concevoir un programme en plusieurs sous-
programmes ralisant chacun un traitement particulier.
Le PC est une autre analogie intressante. Dans un PC, chaque partie est facilement remplaable par une autre :
vous pouvez remplacer l'cran par un autre cran, la carte son par une autre carte son, le clavier par un autre clavier,
etc. Cette possibilit de remplacer chaque partie par une autre partie compatible est possible grce la conception
modulaire du PC. Un programme sans sous-programme est comme un PC en un seul bloc : impossible d'interchanger
les parties.
Sous-programmes non vnementiels
Dans le premier cours, nous avons dj vu quelques sous-programmes.
Les bases de la programmation par Eric Thirion
- 62 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Reprenons l'exemple du projet Addition.
Lorsque l'utilisateur clique sur le bouton, la procdure vnementielle BoutonAdditionnerClick est automatiquement
excute.
Cette procdure vnementielle est un exemple de sous-programme.
Une autre catgorie de sous-programmes, que j'appellerais sous-programmes non vnementiels, ne peuvent
s'excuter que s'il existe quelque part une instruction spciale : l'appel de sous-programme.
De telles instructions figurent l'intrieur de la procdure BoutonAdditionnerClick :
procedure TForm1.BoutonAdditionnerClick(Sender: TObject);
begin
LireEntier (x,zoneTexteX); { <-- }
LireEntier (y,ZoneTexteY); { <-- }
somme := x + y;
AfficherEntier (somme, ZoneTexteSomme); { <-- }
end;
LireEntier et AfficherEntier sont en fait des sous-programmes (non vnementiels). Dans cet exemple, les trois
instructions marques d'une flche sont des appels de sous-programme. LireEntier est donc appel deux fois et
AfficherEntier, une fois.
Par contre, le code du projet Addition ne contient aucun appel du sous-programme BoutonAdditionnerClick.
Comme il s'agit d'un sous-programme vnementiel, son excution sera dclenche par un vnement ; en
l'occurrence, un clic sur le bouton Additionner.
videmment, l'excution des sous-programmes LireEntier et AfficherEntier est galement dclenche, mais de
manire indirecte. Si BoutonAdditionClick ne contenait pas des instructions d'appel de ces procdures, elles ne
seraient jamais excutes !
Les units
Un projet Lazarus est gnralement compos de plusieurs fichiers source Pascal appels units.
Dans le projet Addition, par exemple, nous avons deux modules :
Les bases de la programmation par Eric Thirion
- 63 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
l'unit UnitAddition, qui contient la procdure vnementielle du bouton Additionner ;
l'unit entrees_sorties, qui contient le code des procdures Lire, Afficher, etc.
De manire gnrale, chaque formulaire est associ une unit contenant les procdures vnementielles. C'est
l'unit qui gre l'interface graphique du programme. Dans notre exemple, c'est l'unit UnitAddition. Mais il peut y
avoir plusieurs autres units contenant le code de sous-programmes non vnementiels. Dans notre exemple, il n'y
a qu'une seule unit de ce type. C'est l'unit entrees_sorties.
Procdures et fonctions
Jetons un il dans le fichier entrees_sorties. On y trouve, par exemple, le code du sous-programme AfficherEntier
que voici :
procedure AfficherEntier(x: integer;c:TObject);
begin
if c is TEdit then
(c as TEdit).Text:=IntToStr(x)
else
if c is TListBox then
(c as TListBox).Items.Add(IntToStr(x))
else
begin
ShowMessage('Erreur dans la fonction Afficher :
type du 2e paramtre non valide');
end;
end;
Pour l'instant, vous ne comprenez pas grand-chose ce code, car il fait appel plein de notions que vous n'avez
pas encore vues (structures de contrles, programmation objet). Notez simplement que la premire ligne commence
par le mot-cl procedure, suivi du nom du sous-programme. Cela signifie que le sous-programme appartient la
catgorie des procdures.
droite du nom de la procdure, on trouve les paramtres. Dans cet exemple, il y a deux paramtres : x de type
integer et c de type TObject.
Toute la premire ligne du sous-programme constitue l'entte : elle contient donc le nom du sous-programme et ses
ventuels paramtres. Tout ce qui suit est le corps du sous-programme. l'intrieur du corps du sous-programme
figurent donc les instructions que le sous-programme doit excuter.
Les paramtres sont les donnes d'un sous-programme. Dans le cas de la procdure AfficherEntier, x est le nombre
afficher et c le composant de l'interface graphique (zone de texte ou zone de liste) dans lequel on souhaite afficher x.
Nous reviendrons plus en dtail sur cette notion de paramtres. Pour l'instant, sachez que tout sous-programme peut
avoir des paramtres ou ne pas en avoir.
D'autres sous-programmes du fichier commencent par le mot-cl function. Ce sont les fonctions. C'est par exemple
le cas du sous-programme ZoneDeTexteVide :
function ZoneDeTexteVide (zt: TEdit) : boolean;
begin
ZoneDeTexteVide := zt.Text = '';
end;
Nous avons donc deux catgories de sous-programmes : les procdures et les fonctions. Les diffrences entre ces
deux catgories seront vues dans la suite du cours.
Les bases de la programmation par Eric Thirion
- 64 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Porte des variables
Une variable peut tre de porte locale ou globale. Elle est globale si elle est dclare en dehors de tout sous-
programme. Au contraire, une variable locale est dclare l'intrieur d'un sous-programme.
Mais pour l'instant, nous n'avons pas dfini ce qu'est un sous-programme de manire gnrale. Par contre, vous
savez ce qu'est une procdure vnementielle. Or, les procdures vnementielles reprsentent une catgorie
particulire de sous-programme.
Nous allons donc, pour l'instant, baser nos explications concernant la porte des variables en utilisant uniquement
les procdures vnementielles. Gardez toutefois l'esprit que ces explications seront valables pour n'importe quel
type de sous-programme.
Les variables locales et globales ne se comportent pas de la mme manire, notamment en ce qui concerne leur
dure de vie.
Pour illustrer la diffrence entre une variable locale et une variable globale, nous commencerons par quelques
exemples de programmes, que vous pouvez tlcharger sur le site de l'auteur :
exemple 1 ;
exemple 2 ;
exemple 3 ;
exemple 4.
Vous pouvez donc les ouvrir et les excuter pour vous aider mieux comprendre ou pour vous convaincre.
Exemple 1 (fichier : Global/ProjetGlobal.lpi)
Voici le formulaire du programme :
et voici un extrait du code de ce programme :
var
Form1: TForm1;
x : integer;
implementation
Les bases de la programmation par Eric Thirion
- 65 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
procedure TForm1.BoutonAffecterClick(Sender: TObject);
begin
x := 1961;
end;
procedure TForm1.BoutonAfficherClick(Sender: TObject);
begin
AfficherEntier (x, ZoneTexteX);
end;
Dans ce premier exemple, la variable x est dclare l'extrieur de tout sous-programme. Il s'agit donc d'une variable
globale.
Cela a les consquences suivantes :
x peut tre utilise dans tout le fichier de code o elle est dclare et, par consquent, l'intrieur
de toutes les procdures dfinies dans ce fichier. Dans notre exemple, la variable x est utilise dans
les deux procdures vnementielles BoutonAffecterClick et BoutonAfficherClick. La procdure
BoutonAffecterClick affecte la valeur 1961 x et la procdure BoutonAfficherClick affiche la valeur de x ;
x a une dure de vie gale celle de l'excution du programme : ds le dmarrage du programme, de
l'espace mmoire est allou la variable x. Lorsque le programme s'arrte, cet espace mmoire n'est plus
rserv la variable et on peut donc considrer qu'elle cesse d'exister. Pour vous en convaincre, lancez
le programme, affectez la valeur 1961 x. Vrifiez que x a bien la valeur 1961. Arrtez le programme et
relancez-le. Vous constaterez que x n'a plus la valeur 1961.
Exemple 2 (fichier : Local0/ProjetLocal0.lpi)
Dclarons cette fois-ci la variable x l'intrieur de la procdure BoutonAffecterClick. On obtient le rsultat suivant :
Lazarus affiche un message d'erreur Identifier not found x . Cette erreur est localise dans l'instruction
AfficherEntier(x, ZoneTexteX) de la procdure BoutonAfficherClick.
Lazarus prtend ne pas connatre l'identificateur x dont on parle dans cette instruction.
Or nous avons bien dclar x !
Comment expliquer cette erreur ?
Les bases de la programmation par Eric Thirion
- 66 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le problme vient du fait qu'une variable locale n'est accessible qu' l'intrieur du sous-programme o elle est
dclare. Autrement dit, la porte d'une variable locale est limite ce sous-programme.
Dans notre exemple, x n'est donc dfinie qu' l'intrieur de la procdure BoutonAffecterClick et nulle part ailleurs.
Exemple 3 (fichier : Local1/ProjetLocal1.lpi)
Voici prsent une version lgrement modifie du programme prcdent, dans laquelle la variable x est dclare
au dbut du programme ainsi qu' l'intrieur de la procdure BoutonAffecterClick :
var
Form1: TForm1;
x : integer;
implementation
procedure TForm1.BoutonAffecterClick(Sender: TObject);
var x : integer;
begin
x := 1961;
end;
procedure TForm1.BoutonAfficherClick(Sender: TObject);
begin
AfficherEntier (x, ZoneTexteX);
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
x := 1935;
AfficherEntier (x, ZoneTexteX);
end;
Cet exemple ne provoque aucun message d'erreur.
Vous vous demandez peut-tre comment une telle chose est possible, car a priori une variable ne peut pas tre
dclare deux fois. On devrait avoir un message d'erreur. Or il n'en est rien !
En ralit, il y a deux variables distinctes : la variable x dclare en global et celle dclare en local dans la procdure
BoutonAffecterClick.
Bien qu'elles portent le mme nom, ces deux variables sont totalement indpendantes.
Mais si Lazarus rencontre une instruction utilisant x, comment peut-il savoir de quelle variable il s'agit ?
Il s'en sort de la manire suivante :
l'affectation x := 1961, dans BoutonAffecterClick doit agir sur la variable locale x car x est dfini dans cette
procdure ;
par contre, l'instruction AfficherEntier(x, ZoneTexteX) dans BoutonAfficherClick agit sur la variable globale
x car cette procdure ne contient aucune dclaration de la variable x ;
de mme, les instructions x := 1935 et AfficherEntier (x, ZoneTexteX) dans FormCreate agissent sur la
variable globale.
De manire gnrale :
La dclaration locale est prioritaire sur la dclaration globale.
Les bases de la programmation par Eric Thirion
- 67 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Autrement dit, si une variable globale est redclare l'intrieur de certains sous-programmes alors :
l'intrieur de ces sous-programmes, c'est la dclaration locale qui l'emporte ;
l'intrieur d'un sous-programme dans laquelle cette variable n'est pas redclare, c'est la dclaration
globale qui est prise en compte.
prsent, faites l'exprience suivante :
1 lancez le programme. Il affiche la valeur 1935 pour x ;
2 cliquez sur le bouton Affecter la valeur 1961 X, puis sur Afficher X. Rsultat : la variable x n'a pas t
modifie !
Comment expliquer ceci ?
Lorsque vous lancez le programme, Lazarus excute tout d'abord la procdure FormCreate. Celle-ci affecte la valeur
1935 la variable x dclare en globale, puis affiche la valeur de cette mme variable.
Lorsque vous cliquez sur le bouton Affecter la valeur 1961 X, il excute la procdure BoutonAffecterClick, dans
laquelle x est dclare en local. Cette mme procdure affecte la valeur 1961 x. Mais comme x est dclare dans
cette procdure, cette affectation agit sur la variable x dclare dans cette procdure et non pas sur la variable x
dclare en global.
Enfin, lorsque vous cliquez sur le bouton Afficher X, il excute la procdure BoutonAfficherClick, dans laquelle
ne figure aucune dclaration locale de la variable x. Cette procdure affiche donc la valeur de la variable globale x
qui est toujours gale 1935.
Exemple 4 (fichier : Local2/ProjetLocal2.lpi)
Cette fois-ci, nous dclarons x en local dans toutes les procdures, mais pas en global :
var
Form1: TForm1;
implementation
procedure TForm1.BoutonAffecterClick(Sender: TObject);
var x : integer;
begin
x := 1961;
end;
procedure TForm1.BoutonAfficherClick(Sender: TObject);
var x : integer;
begin
AfficherEntier (x, ZoneTexteX);
end;
procedure TForm1.FormCreate(Sender: TObject);
var x : integer;
begin
x := 1935;
AfficherEntier (x, ZoneTexteX);
end;
Nous avons en ralit ici trois variables locales x indpendantes : celle de la procdure BoutonAffecterClick, celle
de la procdure BoutonAfficherClick et celle de la procdure FormCreate.
Mme exprience qu'avant :
Les bases de la programmation par Eric Thirion
- 68 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
1 lancez le programme. Il affiche la valeur 1935 pour x ;
2 cliquez sur le bouton Affecter la valeur 1961 X, puis sur Afficher X. La valeur affiche est (trs trs
probablement) diffrente de 1961.
Explications :
Lorsque vous lancez le programme, Lazarus excute FormCreate. Ce sous-programme affecte la valeur 1935 la
variable locale x, puis affiche la valeur de cette mme variable.
Lorsque vous cliquez sur le bouton Affecter la valeur 1961 X, il excute le sous-programme BoutonAffecterClick,
qui affecte la valeur 1961 la variable locale x de cette procdure.
Enfin, lorsque vous cliquez sur le bouton Afficher X, il excute le sous-programme BoutonAfficherClick, qui affiche
la valeur de la variable locale x de cette procdure. Comme aucune valeur n'est affecte x dans cette procdure,
cette variable a donc une valeur indfinie.
Synthse
Voil en rsum ce qu'il faut retenir sur les variables locales et globales :
Dfinition
Par dfinition, une variable est locale si elle est dclare l'intrieur d'un sous-programme.
Elle est globale dans le cas contraire.
Porte
Une variable globale est utilisable par tous les sous-programmes contenus dans le fichier o
elle est dclare.
Une variable locale, au contraire, n'est utilisable qu' l'intrieur du sous-programme dans lequel
elle est dclare.
Dure de vie
La dure de vie d'une variable globale est gale celle du programme. La zone mmoire
alloue pour cette variable lui reste alloue tant que le programme s'excute.
La dure de vie d'une variable locale est celle d'une excution du sous-programme dans lequel
elle est dclare. Elle peut donc avoir plusieurs vies : elle renat chaque fois que le sous-
programme s'excute et meurt chaque fois qu'il se termine.
Dclarations locales multiples
Si une mme variable est dclare dans plusieurs sous-programmes, tout se passe comme
si on avait donn des noms de variables distincts pour ces diffrentes dclarations. Autrement
dit, chaque dclaration engendre une variable totalement indpendante des autres.
Les bases de la programmation par Eric Thirion
- 69 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Dclaration simultane en local et en global
Si une mme variable est dclare en local et en global :
dans les sous-programmes o cette variable n'est pas dclare, c'est la dclaration
globale qui est prise en compte ;
l'intrieur des sous-programmes o cette variable est dclare, c'est la dclaration locale
qui est prise en compte.
Exemple d'utilisation de sous-programmes
Utilisation des procdures
Exemple 1
Concevoir un programme l'aide de sous-programmes signifie dcouper un traitement en sous-traitements
spcifiques. Pour illustrer ceci, reprenons le projet Peinture du cours Premires notions.
Rappelons que ce programme permet de calculer la surface peindre d'une pice rectangulaire, connaissant les
dimensions de la pice (longueur, largeur), le nombre de fentres et le nombres de portes.
Cet exemple nous avait justement servi illustrer le principe du dcoupage d'un traitement en sous-traitements.
Lorsqu'un calcul est trop complexe, on a intrt le dcouper en plusieurs calculs intermdiaires et sauvegarder les
rsultats intermdiaires dans des variables.
Cela nous avait donn le code suivant pour le bouton Calculer :
Les bases de la programmation par Eric Thirion
- 70 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Nous avons ici un exemple de code qui peut trs facilement se rcrire l'aide de sous-programmes. Associons un
appel de procdure chaque traitement, cela nous donne :
Comparez ce code celui de la version prcdente : il est devenu plus court et plus lisible.
crivons prsent le code des procdures de calcul. Ce code doit tre crit avant la procdure vnementielle
BT_CalculClick. Il suffit d'crire une entte pour chaque procdure, puis de copier en-dessous l'affectation
correspondante enrobe de begin end. On obtient :
Les bases de la programmation par Eric Thirion
- 71 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Programmation descendante
Remarquez que l'on aurait pu procder ainsi ds le dpart : notre problme est de calculer la surface peindre. Ce
problme peut tre dcompos en quatre sous-problmes : calculer la surface des murs, la surface des fentres, la
surface des portes et finalement la surface peindre.
On associe chaque problme une procdure, ce qui nous permet d'crire le code du programme sans nous occuper
des dtails, c'est--dire avant mme d'avoir rsolu les sous-problmes.
Cette manire de procder est appele la programmation descendante.
Retour d'un sous-programme
Lorsqu'une procdure vnementielle a fini de s'excuter, le programme retourne automatiquement un tat d'attente
d'vnement.
Dans le cas d'un sous-programme non vnementiel, c'est un peu diffrent : l'ordinateur revient l'instruction qui suit
l'appel. Dans le cas du projet Peinture, on obtient ceci :
Les bases de la programmation par Eric Thirion
- 72 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Exemple 2
Dans le premier exemple d'utilisation des procdures, nous avons rcrit le projet Peinture l'aide de procdures
sans paramtres.
L'exemple prsent ici introduit les procdures avec paramtres. Il s'agit d'un programme (sans intrt autre que
pdagogique !) qui permet d'afficher le mail d'une personne de nom et prnom donns :
Le bouton SFR affiche le mail chez SFR, alors que le bouton FREE affiche le mail chez Free. Voici le code de la
procdure vnementielle associe au bouton FREE :
Les bases de la programmation par Eric Thirion
- 73 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
On constate que le code des deux procdures vnementielles associes aux boutons SFR et FREE se ressemble
normment. La seule chose qui change est le nom de l'oprateur.
Pour transformer ces deux traitements quasiment identiques en un seul traitement, on peut utiliser un sous-
programme paramtr par le nom de l'oprateur. Voici le code de ce sous-programme :
procedure AfficherLeMailChez (operateur : string);
var prenom, nom : string;
begin
Lire (prenom, Form1.ZT_Prenom);
Lire (nom, Form1.ZT_Nom);
Afficher (prenom+'.'+nom+'@'+operateur+'.fr', Form1.ZT_Mail);
end;
Le code des deux procdures vnementielles se rsume alors l'appel de cette procdure avec deux valeurs de
paramtres diffrents :
procedure TForm1.BT_SFRClick(Sender: TObject);
begin
AfficherLeMailChez ('sfr');
end;
procedure TForm1.BT_FREEClick(Sender: TObject);
begin
AfficherLeMailChez ('free');
end;
Les valeurs des paramtres l'appel ('sfr' et 'free' dans notre exemple) sont les paramtres effectifs ne pas
confondre avec les paramtres formels : ce sont les paramtres dclars dans l'entte de la procdure. Dans notre
exemple, il n'y a qu'un seul paramtre formel (operateur de type string).
Dtail technique
Un petit dtail technique pour terminer la prsentation de cet exemple. Vous remarquerez que dans le code de la
procdure AfficherLeMailChez, les zones de texte sont toutes prfixes par Form1 :
procedure AfficherLeMailChez (operateur : string);
var prenom, nom : string;
begin
Lire (prenom, Form1.ZT_Prenom);
Lire (nom, Form1.ZT_Nom);
Afficher (prenom+'.'+nom+'@'+operateur+'.fr', Form1.ZT_Mail);
end;
De manire gnrale, pour accder aux composants d'une interface graphique depuis un sous-programme non
vnementiel, il est ncessaire de prfixer les noms de ces composants par le nom du formulaire.
Les bases de la programmation par Eric Thirion
- 74 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
ce stade, nous ne pouvons pas expliquer pourquoi cela est ncessaire car l'explication fait appel des notions
de programmation objet.
Exemple d'utilisation de fonctions
L'exemple prsent ici reprend le projet Peinture en l'crivant avec des fonctions. Ce nouvel exemple se trouve
dans le rpertoire Exemple-Sous-Programme/PeintureAvecFonctions, que vous pouvez tlcharger sur le site
de l'auteur.
Rappelons que le projet Peinture permet de calculer la surface peindre d'une pice rectangulaire, connaissant les
dimensions de la pice (longueur, largeur), le nombre de fentres et le nombre de portes.
Les dimensions des fentres, des portes et la hauteur des murs sont des constantes (LargeurFenetre=1,4 ;
HauteurFenetre=1,2 ; LargeurPorte=0,9 ; HauteurPorte=2,1 ; HauteurMur=2,5).
Ancienne version du projet
La dernire version (rpertoire Exemple-Sous-Programme/Peinture) nous avait servi introduire les procdures.
Nous n'avions alors aucune notion de variables locales, ni de paramtres. Cette version du projet avait donc t
crite en utilisant uniquement des variables globales et des procdures sans paramtre.
Pour calculer la surface peindre l'aide de procdures, nous avions procd par programmation descendante en
dcoupant le problme en quatre sous-problmes :
1 calcul de la surface des murs ;
2 calcul de la surface des fentres ;
3 calcul de la surface des portes ;
4 calcul de la surface peindre.
Nous avions associ une procdure chacun de ces traitements. Voici le code de ces procdures :
Les bases de la programmation par Eric Thirion
- 75 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
et voici l'appel de ces procdures dans la procdure vnementielle associe au bouton Calculer :
Nouvelle version : appel des fonctions
La nouvelle version que nous allons prsenter ici n'utilise au contraire aucune variable globale et effectue des calculs
par l'intermdiaire de fonctions.
Voici le code de cette mme procdure vnementielle dans la nouvelle version :
procedure TForm1.BT_CalculClick(Sender: TObject);
var LargeurPiece, LongueurPiece, Surface_A_Peindre : double;
NFenetre, NPorte : Integer;
begin
LireNombre (LargeurPiece, ZT_Largeur);
LireNombre (LongueurPiece, ZT_Longueur);
LireEntier (NFenetre, ZT_NF);
LireEntier (NPorte, ZT_NP);
Surface_A_Peindre :=
SurfaceDesMurs(LargeurPiece,LongueurPiece)
- SurfaceDesFenetres(NFenetre)
- SurfaceDesPortes(Nporte);
AfficherNombre (Surface_A_Peindre,ZT_SP);
end;
Les bases de la programmation par Eric Thirion
- 76 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Le calcul de la surface peindre se fait prsent en une seule affectation. Plus prcisment, il est reprsent par
l'expression qui appelle trois fonctions :
1 SurfaceDesMurs : cette fonction calcule la surface des murs partir des dimensions de la pice ;
2 SurfaceDesFenetres : elle calcule la surface des fentres partir du nombre de fentres ;
3 SurfaceDesPortes : idem pour les portes partir du nombre de portes.
Nouvelle version : dclaration des fonctions
Voici le code de ces trois fonctions :
L'entte d'une fonction commence ncessairement par le mot cl function. Ce dernier est suivi du nom de la fonction
puis, optionnellement, de la liste des paramtres. Enfin, l'entte se termine par le type du rsultat produit par la
fonction. Dans notre cas, il s'agit du type double, car le rsultat produit est un nombre a priori non entier.
Une fonction se distingue d'une procdure par le fait qu'elle retourne un rsultat. Pour comprendre ce que signifie
retourner un rsultat , il faut voir comment l'ordinateur excute une expression contenant des appels de fonctions.
Nous reviendrons l-dessus un peu plus loin.
Dans notre exemple, chaque fonction ne contient qu'une seule instruction. Ce n'est pas vrai en gnral. Le corps
d'une fonction peut contenir plusieurs instructions. Comment savoir alors quel est le rsultat de la fonction ? En
Pascal, le rsultat d'une fonction est dtermine par la dernire excution d'une affectation de la forme :
Nom de la fonction := expression ;
Il faut donc ncessairement qu'une affectation de ce type soit prsente dans le corps de la fonction afin que le rsultat
retourn par celle-ci soit dfini.
Vous constaterez que, dans notre exemple, chaque fonction contient bien une instruction de ce type.
Retour du rsultat
Voyons maintenant ce que signifie retourner un rsultat . Pour cela, nous allons voir comment est value
l'expression contenant les appels de fonctions :
SurfaceDesMurs(LargeurPiece,LongueurPiece)
- SurfaceDesFenetres(NFenetre)
- SurfaceDesPortes(Nporte);
Les bases de la programmation par Eric Thirion
- 77 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
L'expression est value de gauche droite. L'ordinateur va donc commencer par valuer l'appel de la fonction
SurfaceDesMurs. Supposons que LargeurPiece = 3,6 et LongueurPiece = 4,3.
Comme dans les appels de procdures, les paramtres formels sont remplacs par les paramtres effectifs. Donc
ici, LaP va prendre la valeur 3,6 et LoP, la valeur 4,3. Puis le corps de la fonction est excut avec ces valeurs. La
fonction effectue donc le calcul suivant :
SurfaceDesMurs := 2 * (3,6 + 4,3) * HauteurMur;
Avec une hauteur de mur de 2,50 m, cela fait 39,5 m
2
.
la fin de l'excution de la fonction, ce rsultat va retourner dans l'expression qui l'a appele. Tout se passe
comme si la valeur 39,5 remplaait prsent l'appel de fonction dans cette expression. c'est--dire qu'il faut prsent
valuer l'expression :
39,5 - SurfaceDesFenetres(NFenetre)
- SurfaceDesPortes(Nporte);
Mais l'valuation de l'expression n'est pas termine. L'ordinateur va prsent excuter l'appel de la fonction
SurfaceDesFenetres. Supposons que le nombre de fentres soit gal trois ; nf, le paramtre formel de cette
fonction, va donc prendre la valeur 3 et la fonction va faire le calcul suivant :
SurfaceDesFenetres := 3 * LargeurFenetre * HauteurFenetre;
Avec une largeur de fentre de 1,4 m et une hauteur de fentre de 1,2 m, cela donne 5,04 m
2
.
Celle valeur retourne dans l'expression d'appel et nous obtenons :
39,5 - 5,04 - SurfaceDesPortes(Nporte);
Ici, l'ordinateur va d'abord effectuer la diffrence 39,5 - 5,04. Cela fait 34,46. Nous nous retrouvons donc avec
l'expression :
34,46 - SurfaceDesPortes(Nporte);
Il reste donc valuer l'appel de la fonction SurfaceDesPortes. Supposons deux portes ; le paramtre formel np
prend la valeur 2 et la fonction effectue le calcul suivant :
SurfaceDesPortes := 2 * LargeurPorte * HauteurPorte;
Avec une largeur de porte de 0,9 m et une hauteur de porte de 2,1 m, cela fait 3,78 m
2
. En ramenant ce rsultat
dans l'expression de dpart nous obtenons :
34,46 - 3,78;
Ce qui fait 30,68 m
2
. Vous pouvez vrifier que c'est bien le rsultat affich par le programme :
Les bases de la programmation par Eric Thirion
- 78 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Principes gnraux et complments
Dclaration et appel de procdures
Dclaration d'une procdure
procedure NomDeLaProcdure (liste des paramtres);
Dclaration des variables locales
begin
Instructions
end;
La premire ligne est l'entte de la procdure, forme du mot-cl procedure suivi du nom de la procdure et d'une
liste optionnelle de paramtres entre parenthses.
La partie entre begin et end est le corps de la procdure.
Entte
Sous sa forme la moins compacte, la liste des paramtres s'crit :
paramtre1 : type1,...., paramtreN : typeN
On peut obtenir une criture plus concise en regroupant les paramtres conscutifs de mme type, mais dans ce cas
chaque groupe de paramtres doit tre spar du suivant par un point virgule, sachant qu'un groupe de paramtres
s'crit :
paramtre1,...., paramtreN : type
Les bases de la programmation par Eric Thirion
- 79 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Variables locales
Toute procdure n'utilise pas ncessairement des variables locales, mais si c'est le cas, elles doivent tre dclares
entre l'entte et le premier begin.
criture d'un appel de procdure
L'appel d'une procdure est form du nom de cette procdure suivi d'une liste de paramtres
effectifs entre parenthses.
NomDeLaProcdure (liste des paramtres effectifs);
Dans l'exemple que nous avons prsent, les paramtres effectifs taient des chanes de caractres. De manire
gnrale, la liste des paramtres effectifs est constitue d'expressions quelconques spares par des virgules :
expression1,...., expressionN
Pour que l'appel de procdure soit compilable (et excutable !), le type de ces expressions doit tre compatible avec
celui des paramtres formels :
il doit y avoir autant de paramtres effectifs que de paramtres formels ;
le type d'un paramtre effectif quelconque doit tre compatible avec celui du paramtre formel de mme
position.
Voici par exemple une procdure qui possde trois paramtres formels (p, n ,o) de type chane de caractres :
procedure FormerMail (p, n , o : string);
begin
mail := p+'.'+n+'@'+o+'.fr';
end;
En supposant que Prenom1, Prenom2 et Nom soient des variables de type chane de caractres, elle pourrait tre
appele de la manire suivante :
FormerMail (Prenom1 + '-' + Prenom2, Nom, 'free');
Le premier paramtre effectif est une expression de type chane de caractres, le deuxime une variable de type
chane de caractres et le troisime, un littral de type chane de caractres. Ces trois paramtres effectifs sont donc
compatibles avec les paramtres formels.
Par contre, elle ne pourra tre appele d'aucune des manires suivantes :
FormerMail (Prenom1, Nom);
FormerMail (Prenom1, Nom, 9);
En effet, dans le premier appel, le nombre de paramtres effectifs n'est pas gal au nombre de paramtres formels et
dans le deuxime, le type du troisime paramtre effectif (numrique) n'est pas compatible avec le type du troisime
paramtre formel.
Les bases de la programmation par Eric Thirion
- 80 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Excution d'un appel de procdure
Principe du retour la procdure appelante
Un appel de procdure est toujours contenu dans une autre procdure, que nous appellerons la procdure
appelante.
Lorsqu'un appel de procdure est excut, le processeur interrompt momentanment
l'excution de la procdure appelante pour aller excuter la procdure appele. Aprs avoir
excut les instructions de cette procdure, il reprend l'excution de la procdure appelante
partir de l'instruction qui suivait l'appel.
Passage des paramtres et excution de l'appel
Les paramtres formels d'un sous-programme peuvent tre considrs comme des variables locales.
L'excution d'un appel de procdure consiste :
valuer chacun des paramtres effectifs ;
allouer de la mmoire pour les paramtres formels ;
affecter chaque paramtre formel la valeur du paramtre effectif correspondant ;
excuter le code de la procdure avec ces valeurs de paramtres ;
librer l'espace mmoire allou aux paramtres formels.
Reprenons l'exemple de la procdure FormerMail appele de la manire suivante :
FormerMail (Prenom1+'-'+Prenom2, Nom, 'free');
Les bases de la programmation par Eric Thirion
- 81 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
En supposant que les variables Prenom1, Prenom2 et Nom aient respectivement pour valeur 'Jean', 'Sebastien' et
'Bach', cet appel donnerait lieu aux oprations suivantes :
valuation des paramtres effectifs :
valeur de l'expression Prenom1 + '-' + Prenom2 : 'Jean-Sebastien' ;
valeur de l'expression Nom : 'Bach' ;
valeur de l'expression 'Free' : 'Free'.
allocation mmoire : de la mmoire est alloue aux trois paramtres formels p, n et o ;
affectation des valeurs aux paramtres formels :
la valeur 'Jean-Sebastien' est affecte au paramtre p ;
la valeur 'Bach' est affecte au paramtre n ;
la valeur 'Free' est affecte au paramtre o.
excution du code de la procdure : l'instruction
mail := p + '.' + n + '@' + o + '.fr';
est excute avec ces valeurs de paramtres ;
libration de place mmoire : la place mmoire alloue aux paramtres p, n et o est libre.
Dclaration et appel de fonctions
Dclaration d'une fonction
function NomDeLaFonction (liste des paramtres) : type;
Dclaration des variables locales
begin
Instructions (dont une instruction de retour)
end;
Diffrences avec la dclaration d'une procdure :
l'entte commence par le mot-cl function :
l'entte se termine par le type du rsultat retourn par la fonction ;
parmi les instructions contenues dans le corps de la fonction doit figurer une instruction permettant de
retourner le rsultat. En Pascal, cette instruction s'crit :
NomDeLaFonction := expression;
Appel de fonction
Un appel de fonction s'crit :
NomDeLaFonction (liste des paramtres effectifs)
Les bases de la programmation par Eric Thirion
- 82 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Comme pour les procdures, le nombre de paramtres effectifs doit tre gal au nombre de paramtres formels et
le type d'un paramtre effectif quelconque doit tre compatible avec celui du paramtre formel de mme position.
Diffrences avec un appel de procdure
Un appel de fonction est une expression dont la valeur est celle retourne par la fonction. Un appel de procdure, au
contraire, n'est pas une expression mais une instruction. L'excution d'une procdure ne retourne aucune valeur.
Une appel de fonction figure en gnral l'intrieur d'une instruction ou d'une expression. Par exemple, si Moyenne
est une fonction calculant la moyenne de deux nombres, on peut crire :
m:= Moyenne (A,B);
AfficherNombre (Moyenne (A,B), ZT_Moy)
(Moyenne(A,B) + Moyenne(C,D)) / 2
Un appel de procdure, au contraire, ne peut pas figurer l'intrieur d'une instruction, ni d'une expression.
Les fonctions prdfinies
Comme tous les langages, le Pascal offre une multitude de fonctions prdfinies. Ces fonctions ralisent en gnral
des oprations trs frquemment utilises afin de faciliter la tche du programmeur. On y trouve en particulier les
fonctions mathmatiques ( exemples) et les fonctions de manipulation de chane de caractres ( exemples).
En Pascal, elles sont rparties dans diffrentes units de code. Pour pouvoir les utiliser dans une unit d'un projet,
le nom de ces units doit figurer dans la liste des units importes, c'est--dire aprs uses.
Par dfaut, Lazarus importe huit units dans une unit associe un formulaire :
Les bases de la programmation par Eric Thirion
- 83 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Comme toutes les fonctions prdfinies ne figurent pas dans ces huit units, il faut dans certains cas tendre la liste
des units importes.
Prenons par exemple la fonction floor. Cette fonction retourne la partie entire d'un nombre. Elle figure dans l'unit
Math.pas (fonctions mathmatiques). Pour pouvoir utiliser floor dans une unit, il faut donc ajouter Math dans la
liste des units importes par celle-ci :
Les bases de la programmation par Eric Thirion
- 84 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Expressions et appels de fonctions
Comme nous l'avons dj dit, un appel de fonction est une expression dont la valeur est celle retourne par la fonction.
Cela nous permet d'largir la notion d'expression valide aborde dans le premier cours.
Pour cela, il nous suffit de rajouter la rgle suivante :
Un appel de fonction est une expression valide de type T, si les paramtres effectifs sont
compatibles avec les paramtres formels de la fonction et que cette fonction retourne un rsultat
de type T.
Cette nouvelle rgle, en conjonction avec les rgles dj vues, nous permet de construire des expressions faisant
intervenir des fonctions. Voici quelques exemples utilisant les fonctions prdfinies :
Expression Type Valeur
10+Random(2) Integer 10, 11 ou 12
'Age:' + IntToStr(51) String 'Age : 51'
LeftStr('Thirion',Length('Thirion')-1) String 'Thirio'
Exercices
Retrouvez diffrents exercices sur le site de l'auteur :
Les bases de la programmation par Eric Thirion
- 85 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/

exercices sous Lazarus ;

exercices sur papier.


Pour obtenir les corrigs, le tlchargement n'est possible que via un login et un mot de passe, que vous pouvez
obtenir en envoyant un mail l'adresse suivante :
en prcisant un peu qui vous tes et les raisons pour lesquelles ce cours vous intresse.
Les tableaux
But de ce chapitre
Jusque l, nous n'avons que trs peu de moyens de reprsenter les donnes d'un programme. Une donne en
mmoire est soit une variable de type Integer, soit une variable de type Double, String ou Boolean. Pour chaque
donne du programme, nous avons donc ainsi une unique variable.
En ralit, comme nous allons le voir dans ce cours et le suivant (cours concernant les types structurs), une mme
variable peut contenir un ensemble de donnes. En particulier, lorsque toutes ces donnes sont de mme type, il est
possible de les stocker dans une variable de type tableau.
L'objectif de ce cours est de vous apprendre dfinir et utiliser cette nouvelle manire de reprsenter les donnes.
Les tableaux une dimension
Exemple introductif
Supposons qu'on ait le problme suivant : on voudrait crire une procdure permettant de multiplier dix nombres
entiers par 3.
Les dix entiers sont des variables globales. Il faut donc tout d'abord dclarer dix variables globales :
Var N1, N2, ..., N10 : Integer;
Et la procdure de multiplication devrait comporter dix instructions :
Procedure MultiplierPar3 ();
Begin
N1 := N1 * 3;
N2 := N2 * 3;
.
.
N10 := N10 * 3;
End;
Les bases de la programmation par Eric Thirion
- 86 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Pour dix entiers, cette manire de procder est envisageable. Mais imaginez qu'on ait le mme problme avec un
million d'entiers !
Ne croyez pas, d'ailleurs, que le traitement d'un million d'entiers soit un problme totalement irraliste, car les
ordinateurs ont souvent traiter des millions de nombres en mme temps. En informatique, ce type de problme
est tout fait courant.
Malheureusement, on ne peut pas utiliser de boucle pour faire ceci, car on n'a aucun moyen de faire varier le nom
d'une variable !
On aurait envie d'crire quelque chose du genre :
Var i : Integer;
For i:=1 To 10 Do Var Ni : Integer;
Procedure MultiplierPar3 ();
Var i : Integer;
Begin
For i := 1 To 10 Do Ni := Ni * 3;
End;
en pensant que Ni serait successivement remplac par N1, N2, , N10.
Malheureusement, ce mcanisme de gnration automatique de nom de variable n'est pas possible !
Alors, comment faire ?
La solution est d'utiliser un tableau.
Pour utiliser un tableau, il faut tout d'abord dclarer une variable de type tableau.
Avec l'exemple prcdent, ce serait :
Var N : array [1 .. 10] Of Integer;
Cette criture revient dclarer dix entiers N1, N2, , N10, mais elle est beaucoup plus concise. Lorsqu'un
interprteur ou un compilateur rencontre une dclaration de tableau dans un programme, il alloue de la mmoire
pour l'ensemble du tableau. Dans notre exemple, il y aurait donc une allocation mmoire de 20 octets en supposant
des entiers 16 bits :
D'autre part, il devient prsent possible de multiplier les dix entiers du tableau par 3 avec une boucle For, comme
ceci :
Les bases de la programmation par Eric Thirion
- 87 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Procedure MultiplierPar3 ();
Var i : Integer;
Begin
For i := 1 To 10 Do N[i] := N[i] * 3;
End;
L'criture N[i] dsigne le ime lment du tableau, autrement dit l'lment d'indice i du tableau N.
Vous constaterez qu'avec un million d'entiers, le code du programme n'est pas plus long :
Var N : array [1 .. 1000000] of Integer;
Procedure MultiplierPar3 ();
Var i : Integer;
Begin
For i := 1 To 1000000 Do N[i] := N[i] * 3;
End;
Le cas gnral
En Pascal, la dclaration d'un tableau s'crit :
Var nom du tableau
: array [indice min .. indice max] Of type des lments;
o indice min et indice max sont deux entiers qui reprsentent respectivement le plus petit indice et le plus grand
indice des lments du tableau.
Le type des lments peut varier d'un tableau l'autre, mais tous les lments d'un mme tableau sont forcment
du mme type.
Voici, par exemple, la dclaration d'un tableau de chanes de caractres :
Var Prenom : array [1..1000 ] Of String;
On pourra ensuite affecter une valeur un lment du tableau, tout comme on affecte une valeur une variable.
Par exemple l'instruction :
Prenom[3] := 'Jeanne';
Les bases de la programmation par Eric Thirion
- 88 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
affecte la chane de caractres 'Jeanne' l'lment d'indice 3 du tableau Prenom.
Utilisation de constantes pour dfinir la dimension d'un tableau
Supposons que vous ayez modifier un programme trs long (plusieurs milliers de lignes, par exemple), qui utilise
un tableau de T de dix entiers dclar par :
Var T : array [1 .. 10] Of Integer;
On vous demande de changer la dimension du tableau T de 10 20.
Supposons que dans ce programme figurent des centaines d'instructions faisant rfrence la dimension du tableau
T, c'est--dire au nombre 10.
Dans toutes ces instructions, il va donc falloir remplacer le nombre 10 par le nombre 20.
Les constantes servent en particulier viter ce genre de manipulation longue et fastidieuse.
Supposons prsent que le programme initial ait t crit en utilisant une constante DIMENSION, qui reprsente le
nombre d'lments du tableau T, dclare comme suit :
Const DIMENSION = 10;
et que le tableau soit dclar comme suit :
Var T : array [1..DIMENSION] of Integer;
Si le dveloppeur qui a crit le programme a bien fait les choses, il aura fait rfrence la constante DIMENSION
(et non pas 10 !) dans toutes les instructions utilisant la dimension du tableau T.
Un programme crit de cette manire est beaucoup plus facile mettre jour. En effet, pour changer la dimension du
tableau de 10 20, il vous suffit prsent de modifier une seule ligne de programme : la dclaration de la constante
DIMENSION. c'est--dire que vous allez la remplacer par :
Const DIMENSION = 20;
et tout le reste fonctionnera tout seul !
Vous vous demandez peut-tre pourquoi on n'aurait pas pu utiliser une variable la place de la constante. c'est-
-dire dclarer :
Var DIMENSION : Integer;
T : array [1..DIMENSION] of Integer;
puis faire DIMENSION := 10; au dbut du programme.
Ceci ne fonctionne pas !
Pourquoi ?
Parce que la dimension d'un tableau ne peut pas tre modifie pendant l'excution d'un
programme.
Les bases de la programmation par Eric Thirion
- 89 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
En effet, un tableau est un objet statique, c'est--dire que l'espace mmoire qui lui est allou ne peut tre modifi
en cours d'excution.
Cela prsente un certain nombre d'inconvnients. En particulier, si vous ne connaissez pas a priori la taille de tableau
qu'il vous faudra pour rsoudre un problme particulier, la seule solution que vous avez est de prvoir large, de
manire ce que vous ne risquiez pas d'avoir un dpassement de capacit (taille de tableau insuffisante pour
enregistrer toutes les donnes).
Nous verrons ultrieurement qu'il existe d'autres manires de reprsenter les informations en mmoire (on parle de
structures de donnes), qui permettent d'viter ce problme.
Tableaux remplis partiellement
Reprsentation
Nous avons vu qu'un tableau est un objet statique, c'est--dire que sa dimension ne peut pas tre modifie pendant
l'excution d'un programme.
Il faut donc toujours prvoir large, c'est--dire dclarer un tableau de taille suffisante pour tous les cas de figure.
Cela signifie que l'on va, en gnral, remplir les tableaux partiellement jusqu' un certain indice dfinissant la fin
des donnes.
Pour reprsenter un tableau rempli partiellement, il faut donc ncessairement une variable entire qui contiendra
tout moment l'indice de fin des donnes.
Pour fixer les ides, prenons une variable T pour le tableau et une variable N pour l'indice de fin. On aura donc les
dclarations suivantes :
Const M = Nombre maximum d'lments;
Var N : Integer;
T : array [1..M] of Type;
Les donnes utiles sont stockes dans les N premiers lments du tableau :
Le tableau est vide lorsque N vaut 0 et plein lorsque N est gal M :
Les bases de la programmation par Eric Thirion
- 90 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Adjonction d'une valeur
Adjonction la fin
Pour ajouter une valeur V un tableau rempli partiellement, le plus simple est de l'ajouter la fin. On appelle cette
opration empiler. L'lment qui suit le dernier prend la valeur V et l'indice de fin est incrment :
T [N+1] := V;
N := N+1;
Insertion
Insrer une valeur dans un tableau est une opration plus complexe. Supposons que l'on souhaite insrer une valeur
V l'indice P (P N) du tableau. Il faut d'abord faire de la place pour cette nouvelle valeur, c'est--dire dcaler
toutes les valeurs entre les indices P et N, d'un cran vers la droite. La valeur V peut ensuite tre affecte l'lment
d'indice P. Puis, comme on a ajout une valeur, l'indice de fin augmente de 1 :
Les bases de la programmation par Eric Thirion
- 91 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
For i := N DownTo P Do T[i+1] := T[i];
T[P] := V;
N := N+1;
Suppression d'un lment
Suppression du dernier lment
Le dernier lment d'un tableau est le plus simple supprimer ; pour cela, il suffit de dpiler, c'est--dire de
dcrmenter l'indice de fin de 1 :
N := N - 1;
Suppression d'un lment quelconque (diffrent du dernier)
Supprimer l'lment d'indice P (P < N ) signifie dcaler toutes les valeurs qui suivent P d'un cran vers la gauche,
puis dcrmenter l'indice de fin :
Les bases de la programmation par Eric Thirion
- 92 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
For i := P To N-1 Do T[i] := T[i+1];
N := N-1;
Notion de pile
Un tableau rempli partiellement sur lequel on ne fait que des oprations empiler et dpiler est une structure de
donnes fondamentale de l'informatique que l'on appelle une pile (stack en anglais).
En particulier, la gestion mmoire des variables locales et des paramtres des sous-programmes utilise une pile : les
valeurs des variables sont empiles lorsque l'on rentre dans le sous-programme et dpiles la sortie.
Les tableaux deux dimensions
Dclaration en Pascal
var T : array [ 1..3,1..4 ] of integer;
T [ i , j ] est l'lment de T se trouvant la ligne i et la colonne j.
Exemple : T [2, 3] := 10;
Les bases de la programmation par Eric Thirion
- 93 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Traitement de tous les lments
Principe :
for i := 1 to 3 do
begin
for j := 1 to 4 do
begin
Traitement de l'lment T[ i, j ]
end
end
Exemple :
for i := 1 to 3 do
begin
for j := 1 to 4 do
begin
T [ i , j ] := j + 3 * (i - 1) ;
end
end
Traitement d'une ligne
Principe : traitement de la ligne i :
for j := 1 to 4 do
begin
Traitement de l'lment T[ i, j ]
end
Exemple : traitement de la ligne 2 :
for j:= 1 to 4 do
begin
T [2, j ] := 2 * j ;
end
Traitement d'une colonne
Principe : traitement de la colonne j :
Les bases de la programmation par Eric Thirion
- 94 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
for i := 1 to 3 do
begin
Traitement de l'lment T[ i, j ]
end
Exemple : traitement de la colonne 3 :
for i := 1 to 3 do
begin
T [ i, 3 ] := 4 - i ;
end
Exercices
Retrouvez les noncs d'exercices sur le site de l'auteur :
les tableaux une dimension :

exercices sous Lazarus,

exercices sur papier.

tableaux remplis partiellement ;

les tableaux deux dimensions.


Pour obtenir les corrigs, le tlchargement n'est possible que via un login et un mot de passe, que vous pouvez
obtenir en envoyant un mail l'adresse suivante :
en prcisant un peu qui vous tes et les raisons pour lesquelles ce cours vous intresse.
Structures de contrle
But de ce chapitre
Avec ce que nous avons vu dans les deux premiers cours (Premires notions et Sous-programmes), un programme
se prsente comme un ensemble de sous-programmes qui ne contiennent que deux types d'instructions : des
affectations ou des appels de procdures.
Les programmes de ce type ont deux limitations importantes, qui disparatront avec les nouvelles notions introduites
dans ce cours.
Les bases de la programmation par Eric Thirion
- 95 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Premirement, ils ne peuvent pas s'adapter aux donnes qu'ils traitent. Ils ne pourront donc jamais traiter diffrents
cas de figure ni se protger contre l'introduction de donnes errones. Cette limitation disparatra avec l'introduction
des conditionnelles.
La deuxime limitation concerne les traitements itratifs dont nous avons dj eu un aperu dans le premier cours.
Mais il s'agissait alors de traitements itratifs raliss manuellement par l'utilisateur. Pour rpter un traitement,
il reclique sur le bouton concern. En fait, de nombreux problmes informatiques ncessitent de pouvoir rpter
automatiquement des instructions. Or nous n'avons pour l'instant qu'un seul moyen de le faire : dupliquer ces
instructions dans le code autant de fois que ncessaire. Cette solution n'est videmment pas trs pratique. Et
comment faire alors si le nombre de rptitions dpend des donnes ?
Cette deuxime limitation disparatra avec l'introduction des boucles.
Les conditionnelles et les boucles utilisent toutes les deux un type d'expression que nous n'avons pas encore tudi :
les expressions logiques.
Nous allons donc commencer par l.
Les expressions logiques
Variable boolenne
Le type boolen est un type de variable, tout comme les types entier ou chane de caractres.
Une variable de ce type sert reprsenter une information qui peut tre vraie ou fausse.
Par exemple, dans un programme de gestion de marchandises, on pourrait avoir une variable RuptureDeStock qui
nous permettrait de savoir si le stock de marchandises est puis.
De manire gnrale :
Une variable boolenne est une variable qui peut prendre deux valeurs : true (vrai) et false
(faux).
Il n'y a donc que deux littraux de type boolen.
En Pascal, le type boolen se note Boolean et une variable boolenne se dclare de la manire suivante :
Var nom de la variable : Boolean;
On pourrait par exemple crire :
Var RuptureDeStock : Boolean;
RuptureDeStock := True;
La premire instruction dclare une variable boolenne nomme RuptureDeStock. La deuxime lui affecte la valeur
True.
Oprateurs logiques
Nous avons dj vu quelques oprateurs : les oprateurs arithmtiques, qui agissent sur des nombres, ainsi que
l'oprateur de concatnation, qui agit sur des chanes de caractres.
Les bases de la programmation par Eric Thirion
- 96 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
De la mme manire, il existe des oprateurs logiques. Ceux-ci permettent de calculer une valeur logique (donc vrai
ou faux) partir d'autres valeurs logiques.
Il existe principalement trois oprateurs logiques : la ngation , la conjonction et la disjonction.
La ngation
En logique, la ngation permet de reprsenter le contraire d'une proposition.
Si quelque chose est vrai, alors son contraire est faux et rciproquement.
En Pascal, l'oprateur de ngation se note Not.
La table suivante (que l'on appelle table de vrit) rsume l'effet de l'oprateur de ngation :
X Not X
True False
False True
Par exemple, avec deux variables boolennes ArticleDisponible et RuptureDeStock, on pourrait crire :
ArticleDisponible := Not RuptureDeStock;
Si RuptureDeStock vaut true avant cette affectation, alors ArticleDisponible vaudra false aprs cette affectation.
Rciproquement, si RuptureDeStock vaut False avant cette affectation, alors ArticleDisponible vaudra true aprs
cette affectation.
La conjonction
La conjonction, reprsente en Pascal par l'oprateur And, permet d'exprimer le fait que deux choses sont vraies
simultanment.
Voil la table de vrit de l'oprateur And :
X Y X And Y
False False False
False True False
True False False
True True True
Prenons un exemple.
La variable boolenne AmpouleFonctionne reprsente le fait qu'une ampoule lectrique fonctionne.
Une autre variable boolenne InterrupteurOn est vraie si et seulement si l'interrupteur est en position On.
La variable boolenne LumiereAllumee reprsente le fait que la lumire est allume.
Aprs l'affectation suivante :
LumiereAllumee := AmpouleFonctionne And InterrupteurOn;
Les bases de la programmation par Eric Thirion
- 97 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
la variable LumiereAllumee ne vaudra True que si les variables AmpouleFonctionne et InterrupteurOn valaient
galement True juste avant l'affectation.
La disjonction
La disjonction de deux propositions est vraie si et seulement si au moins une de ces deux propositions est vraie.
Autrement dit, la disjonction de deux propositions n'est fausse que lorsque ces deux propositions sont fausses.
Par exemple, la proposition Il est bte ou il ne comprend pas ne sera fausse que si l'individu en question n'est
pas bte et a trs bien compris.
Attention ! Le ou logique n'est pas un ou exclusif . La disjonction de deux propositions
est vraie lorsque les deux propositions sont vraies. Par exemple, l'affirmation Il pleut ou il y a
du soleil est vraie lorsqu'il pleut et qu'il y a du soleil en mme temps.
L'oprateur de disjonction est reprsent en Pascal par le mot-cl Or. Voici sa table de vrit :
X Y X Or Y
False False False
False True True
True False True
True True True
Prenons un exemple.
La variable boolenne AmpouleFoutue reprsente le fait qu'une ampoule lectrique ne fonctionne pas.
Une autre variable boolenne InterrupteurOff est vraie si et seulement si l'interrupteur est en position Off.
La variable boolenne LumiereEteinte reprsente le fait que la lumire est teinte.
Aprs l'affectation suivante :
LumiereEteinte := AmpouleFoutue Or InterrupteurOff;
la variable LumiereEteinte ne vaudra True que si la variable AmpouleFoutue et/ou la variable InterrupteurOff
avaient la valeur True juste avant l'affectation.
Expressions logiques
Une expression logique est une expression de type boolen, c'est--dire une expression
pouvant prendre la valeur vrai ou faux.
Les variables boolennes
Vous connaissez dj un cas particulirement simple d'expression logique : ce sont les noms de variables
boolennes.
Par exemple, si la variable LumiereEteinte est dclare comme une variable boolenne, le simple nom de variable
LumiereEteinte peut tre considr comme une expression logique.
Les bases de la programmation par Eric Thirion
- 98 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Utilisation des oprateurs logiques
On peut galement construire des expressions logiques en combinant d'autres expressions logiques avec les
oprateurs Not, And, Or.
Supposons, par exemple, que x, y et z soient des variables boolennes. Alors Not x, x And y, x Or y sont des
expressions logiques. Tout comme z Or (x And y), (Not z And x) et (x Or y)
De manire gnrale :
Si E est une expression logique, alors Not E est une expression logique.
Si E et F sont des expressions logiques, alors E And F est une expression logique.
Si E et F sont des expressions logiques, alors E Or F est une expression logique.
Si E est une expression logique, alors (E) est une expression logique.
Utilisation des oprateurs de comparaison
Il existe encore un autre moyen de construire une expression logique : en utilisant des oprateurs de comparaison.
Un oprateur de comparaison est un oprateur qui permet de comparer deux expressions
de mme type.
Les six oprateurs
Il existe six oprateurs de comparaison :
Symboles mathmatiques Signification
= gal
Diffrent de
< Strictement infrieur
> Strictement suprieur
Infrieur ou gal
Suprieur ou gal
La notation des oprateurs de comparaison varie selon les langages :
Symboles mathmatiques Pascal Langage C
= = ==
<> !=
< < <
> > >
<= <=
>= >=
Comparaison d'expressions numriques
L'utilisation la plus frquente des oprateurs de comparaison est la comparaison d'expressions numriques.
La plus simple est la comparaison directe de deux variables numriques. Exemple :
Les bases de la programmation par Eric Thirion
- 99 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
x y x = y x <> y x < y x >= y x > y x <= y
1 1 True False False True False True
1 2 False True True False False True
2 1 False True False True True False
Mais on peut bien sr comparer des expressions numriques quelconques. Par exemple, pour x = 1 et y = 2, on aurait :
Expression logique Valeur
(x+1) = y True
(x+1)*(y+1) = 6 True
x+1 <= 2 True
x-1 < -y False
Comparaison de chanes de caractres
En Pascal, les six oprateurs de comparaison peuvent tre utiliss avec des chanes de caractres, en se basant
sur l'ordre alphabtique. Exemple :
x y x = y x <> y x < y x >= y x > y x <= y
'Trac' 'Trac' True False False True False True
'Trac' 'Truc' False True True False False True
'Truc' 'Trac' False True False True True False
Exercices

noncs ;
Pour obtenir les corrigs, rendez-vous au bas de la page.
La conditionnelle
La programmation n'aurait que trs peu d'intrt si elle ne permettait pas aux ordinateurs de ragir diffremment
selon diffrentes conditions.
Une machine programmable doit pouvoir effectuer des traitements diffrents selon les donnes qu'elle doit traiter.
Cela est possible grce l'existence des structures de contrle dans les langages de programmation : la
conditionnelle et les boucles.
L'objet de ce chapitre est d'expliquer le fonctionnement d'une conditionnelle.
Le If
La conditionnelle If existe en deux variantes : le If ... Then et le If Then Else.
Le If Then
La structure de contrle If Then s'crit de la manire suivante :
If condition Then
Begin
Les bases de la programmation par Eric Thirion
- 100 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Instructions excuter
si la condition est vraie
End;
La condition n'est rien d'autre qu'une expression logique.
Les instructions entre begin et end ne seront excutes que si la condition est vraie.
S'il n'y a qu'une seule instruction excuter, on peut omettre les mots-cls begin et end :
If condition Then Instruction excuter;
Prenons un exemple :
If n > 0 Then n := n - 1;
Si, par exemple, n vaut 5 juste avant l'excution du If Then, la condition n > 0 est vrifie. L'ordinateur va donc
excuter l'affectation n := n - 1. n vaudra donc 4 la sortie de la conditionnelle.
Si n vaut -1, par contre, la condition n > 0 n'est pas vrifie. L'affectation ne sera pas excute et n vaudra toujours
-1 la sortie de la conditionnelle.
Le If Then Else
Le If Then Else est une autre forme de conditionnelle.
Elle permet d'excuter certaines instructions si une condition est vraie, et d'autres si elle est fausse.
Voil sa syntaxe :
If condition Then
begin
Instructions excuter
si la condition est vraie
End
Else
begin
Instructions excuter
si la condition est fausse
End;
De mme, les begin et end ne sont pas ncessaires s'il n'y a qu'une seule instruction.
Prenons un exemple :
If n > 0 Then
n := n - 1
Else
n := n + 1;
Remarquez que nous n'avons pas mis de point-virgule aprs la premire affectation. Si nous l'avions fait, le
compilateur aurait gnr une erreur de syntaxe, car il aurait interprt ceci comme un if then simple suivi du
mot-cl else, qui n'aurait rien voir ici dans ce cas.
Par contre, le point-virgule est ncessaire aprs la deuxime affectation pour marquer la fin de la conditionnelle.
Que se passe-t-il lors de l'excution de cette conditionnelle ?
Les bases de la programmation par Eric Thirion
- 101 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Supposons, par exemple, que n vaut 5 juste avant l'excution du If Then Else. La condition n > 0 est vrifie.
L'ordinateur va donc excuter l'affectation n := n - 1. Par contre, l'affectation n := n + 1 ne sera pas excute. n
vaudra donc 4 la sortie de la conditionnelle.
Si n vaut -1, par contre, la condition n > 0 n'est pas vrifie. L'affectation n := n - 1 n'est donc pas excute. Mais
comme la condition est fausse, l'affectation n := n + 1 sera excute. n vaudra donc 0 la sortie de la conditionnelle.
If imbriqus
Les instructions l'intrieur d'un If ne sont pas forcment des affectations comme dans les exemples prcdents.
On peut galement y mettre d'autres structures de contrle et, en particulier, d'autres If.
Exemple :
If n > 0 Then
n := n - 1
Else
If n >= -3 Then
n := n + 1
Else
n := 2 * n;
Pour n = 5, l'instruction excute est n := n - 1. n vaudra donc 4 la sortie de la conditionnelle.
Pour n = -1, l'instruction excute est n := n + 1. n vaudra donc 0 la sortie de la conditionnelle.
Pour n = -4, l'instruction excute est n := 2 * n. n vaudra donc -8 la sortie de la conditionnelle.
Dans l'exemple prcdent, on a deux niveaux d'imbrication. Mais on peut avoir autant de niveaux d'imbrication qu'on
le souhaite.
L'instruction Exit
L'imbrication de If peut conduire des programmes plus rapides (voir l'exercice Min-Max-Med), mais elle peut
galement compliquer l'criture du code, notamment dans la protection d'un programme contre les erreurs.
Prenons par exemple un programme utilisant une date dfinie par un jour (nombre entier entre 1 et 31), un mois
(nombre entier entre 1 et 12) et une anne de ce sicle (nombre entier suprieur 2000). Ces trois donnes sont
lues depuis trois zones de texte (respectivement ZT_Jour, ZT_Mois et ZT_Annee) dans des variables entires,
respectivement Jour, Mois, Annee. Ce traitement est effectu par la procdure vnementielle associe au bouton
BT_GererDate.
Pour tester la validit de ces donnes avec des If imbriqus, on crirait le code suivant :
procedure TForm1.BT_GererDateClick(Sender: TObject)
var Jour,Mois,Annee: integer;
begin
LireEntier (Jour, ZT_Jour);
If ( Jour < 1) or (Jour > 31) Then
ShowMessage ('Numro du jour non valide!')
Else
begin
LireEntier (Mois, ZT_Mois);
If (Mois < 1) or (Mois > 12) Then
ShowMessage('Numro du mois non valide!')
Else
Begin
Les bases de la programmation par Eric Thirion
- 102 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
LireEntier(Annee,ZT_Annee);
If Annee < 2000 Then
ShowMessage ('Anne non valide!')
Else
Begin
Traitement de la date
End
End
End
End;
Pour raccourcir ce genre d'criture, on peut utiliser l'instruction Exit, qui permet de forcer la fin de l'excution du sous-
programme qui la contient. Avec cette instruction, l'exemple prcdent peut tre crit sans aucune imbrication de If :
procedure TForm1.BT_GererDateClick(Sender: TObject)
var Jour,Mois,Annee: integer;
begin
LireEntier (Jour, ZT_Jour);
If ( Jour < 1) or (Jour > 31) Then
Begin ShowMessage ('Numro du jour non valide!'); Exit End;

LireEntier (Mois, ZT_Mois);
If (Mois < 1) or (Mois > 12) Then
Begin ShowMessage('Numro du mois non valide!'); Exit End;

LireEntier(Annee,ZT_Annee);
If Annee < 2000 Then
Begin ShowMessage ('Anne non valide!'); Exit End;
Traitement de la date
End;
Case
La conditionnelle Case est utilise lorsque l'on veut effectuer diffrents traitements selon la valeur d'une expression
quelconque.
Voici sa syntaxe :
Case Expression Of
V1 :
Instructions excuter lorsque
l'expression vaut V1 ;
V2 :
Instructions excuter lorsque
l'expression vaut V2 ;
.
.
VN :
Instructions excuter lorsque
l'expression vaut VN ;
Else
Instructions excuter dans les autres cas ;
End;
La partie Else est optionnelle.
Voici, par exemple, comment dterminer le nom d'un mois en fonction de son numro avec une instruction Case :
Case NumeroMois Of
1 : NomMois :='janvier';
2 : NomMois :='fvrier';
.
Les bases de la programmation par Eric Thirion
- 103 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
.
12 : NomMois :='dcembre';
Else
ShowMessage ('Numro de mois inexistant!')
End;
Exercices

Exercices avec ordinateur ;

Exercices sans ordinateur ;


Pour obtenir les corrigs, rendez-vous au bas de la page.
Les boucles
Tout comme les conditionnelles, les boucles sont des structures de contrle fondamentales de la programmation.
Par l'intermdiaire d'une boucle, on peut demander un ordinateur de rpter une partie du code.
Nous allons prsenter trois types de boucles : les boucles While, les boucles Repeat et les boucles For.
En fait, la boucle While suffirait crire n'importe quel programme. Mais dans certains cas, l'criture d'une boucle
avec Repeat ou avec For est plus pratique.
Les boucles While
Une boucle While permet de rpter du code tant qu'une certaine condition est vraie.
Elle s'crit de la manire suivante :
While condition do
begin
Instructions rpter
tant que la condition est vraie
End;
La condition est une expression logique quelconque.
Voil un exemple prcis de boucle While :
S := 0;
i := 1;
While i <= n Do
begin
S := S + i;
i := i + 1;
End;
Cette boucle permet de calculer la somme S des n premiers entiers : 1 + 2 + 3 + + n. Pour n = 4, on aura par
exemple S = 1 + 2 + 3 + 4 = 10 la fin de l'excution de ce code.
Vocabulaire associ aux boucles
Un peu de vocabulaire :
Les bases de la programmation par Eric Thirion
- 104 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Chaque excution du code l'intrieur d'une boucle s'appelle une itration.
Dans notre exemple, une itration est une excution des instructions S := S + i; et i := i + 1;.
Gnralement, une boucle est prcde d'un certain nombre d'affectations que l'on appelle des
initialisations. Elles servent donner des valeurs initiales aux variables de la boucle (c'est--
dire toutes celles qui vont varier dans la boucle).
Dans notre exemple, ce sont les instructions S := 0 et i := 1.
Dans une boucle, on trouve frquemment une variable qui joue le rle de compteur (car elle
compte en quelque sorte le nombre d'itrations). La valeur de cette variable est augmente de
1 chaque itration par une instruction de la forme variable := variable + 1, que l'on appelle
une incrmentation.
Dans notre exemple, le compteur est reprsent par la variable i. chaque itration, la valeur de i est incrmente
par l'affectation i := i + 1.
Droulement de la boucle
Nous allons prsent drouler la boucle donne en exemple, c'est--dire dtailler toutes les instructions qui seront
excutes jusqu' ce que la boucle s'arrte.
Supposons que n vaut 3 avant d'entrer dans la boucle. Voil exactement ce qui se passe lorsque cette boucle est
excute :
Instruction
excute
Valeur de i Valeur de S
S := 0 0 0
i := 1 1 0
Initialisation
S := S + i 1 1
i := i + 1 2 1
1re itration
S := S + i 2 3
i := i + 1 3 3
2e itration
S := S + i 3 6
i := i + 1 4 6
3e itration
Dans une boucle While, la condition d'arrt est teste avant l'excution d'une itration.
Donc avant d'entrer la premire fois dans la boucle, l'ordinateur va tester la condition i n. Comme i vaut 1 et n vaut
3, il va rentrer dans la boucle et faire une premire itration.
la fin de la premire itration, i vaut 2. La condition i n est toujours vrifie. L'ordinateur va donc faire une
deuxime itration.
la fin de la deuxime itration, i vaut 3. La condition i n est toujours vrifie. L'ordinateur va donc faire une
troisime itration.
la fin de la troisime itration, i vaut 4. Ce sera donc la dernire itration, car prsent la condition i n est fausse.
Les bases de la programmation par Eric Thirion
- 105 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les boucles Repeat
La boucle Repeat s'crit de la manire suivante :
Repeat
Instructions rpter
jusqu' ce que la condition soit vraie
Until condition
Remarques :
avec une boucle Repeat, le code rpter est toujours excut au moins une fois ;
il n'y a pas de Begin End englobant les instructions rpter, car Repeat et Until jouent dj ce rle.
Voici par exemple comment calculer la somme des n premiers nombres entiers avec une boucle Repeat :
S := 0;
i := 0;
Repeat
i := i + 1;
S := S+ i
Until i = n;
Comme prcdemment, supposons que n vaut 3 et voyons ce qui se passe exactement lorsque la boucle Repeat
est excute :
Instruction
excute
Valeur de i Valeur de S
S := 0 0 0
i := 0 0 0
Avant d'entrer
dans la boucle
i := i + 1 1 0
S := S + i 1 1
1re itration
i := i + 1 2 1
S := S + i 2 3
2e itration
i := i + 1 3 3
S := S + i 3 6
3e itration
Avant d'entrer dans la boucle, S et i sont initialiss 0.
la fin de chaque itration, l'ordinateur va tester si i est gal n (donc 3 dans notre exemple).
Cette condition n'est ralise qu' la fin de la troisime itration.
Les boucles For
Fondamentalement, une boucle For n'est rien d'autre qu'un raccourci d'criture pour un certain type de boucle While
que l'on rencontre trs frquemment :
compteur := valeur initiale;
While compteur <= valeur finale Do
Begin
Instructions rpter
compteur := compteur + 1;
End;
Les bases de la programmation par Eric Thirion
- 106 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Avant la boucle, on affecte une valeur initiale au compteur.
chaque itration, le compteur est incrment.
La boucle s'arrte ds que le compteur dpasse la valeur finale.
La boucle For permet d'crire ce type de boucle de manire plus concise, comme suit :
For compteur := valeur initiale To valeur finale Do
Begin
Instructions rpter
End;
On conomise ainsi l'criture de l'incrmentation du compteur l'intrieur de la boucle.
Attention : l'incrmentation du compteur n'est pas crite, mais elle est bien excute.
Voici, par exemple, la somme des n premiers nombres entiers avec une boucle For et avec une boucle While :
En boucle For En boucle While
S := 0;
For i := 1 To n Do
Begin
S := S+i
End
S := 0;
i := 1;
While i <= n Do
Begin
S := S+i;
i := i+1
End
Exercices

noncs ;
Pour obtenir les corrigs, voyez ci-dessous.
Corrigs des exercices
Pour obtenir les corrigs, le tlchargement n'est possible que via un login et un mot de passe, que vous pouvez
obtenir en envoyant un mail l'adresse suivante :
en prcisant un peu qui vous tes et les raisons pour lesquelles ce cours vous intresse.
Les bases de la programmation par Eric Thirion
- 107 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les types structurs
Introduction
Dans le cours sur les tableaux, nous avons vu un premier moyen de mmoriser un ensemble de donnes dans
une variable. Cette manire de procder est toutefois limite des donnes de mme type. Les types structurs
que nous allons prsenter dans ce cours permettent de lever cette limitation.
Une autre limitation importante des tableaux est qu'ils sont de dimension fixe. On est donc souvent contraint de les
surdimensionner, afin de s'assurer qu'ils pourront stocker toutes les donnes traiter. Dans ce cours, nous allons
voir comment stocker des ensembles de donnes de taille variable sous formes de listes. Avec cette nouvelle
reprsentation, il sera possible d'utiliser une place mmoire proportionnelle au nombre de donnes mmoriser.
Les types structurs
Gnralits indpendantes du langage de programmation
Les concepts manipuls par l'tre humain peuvent souvent tre dcrits par des attributs : un rectangle est caractris
par sa largeur et sa longueur ; un livre peut tre dcrit par son titre, son auteur, son anne de publication ; une voiture
par sa marque, sa couleur, son kilomtrage, sa puissance, etc.
Pour pouvoir reprsenter informatiquement de tels concepts, les langages de programmation permettent de dfinir
des types structurs. Contrairement un type prdfini du langage (entier, rel, boolen, etc.), le nom d'un type
structur est dfini par le programmeur. Il pourra par exemple dfinir un type Livre , puis dclarer ensuite des
variables de ce type.
Dclaration
Dclaration d'un type structur
Prenons l'exemple du concept Livre . Pour reprsenter informatiquement un livre dans un programme Pascal, on
pourra dfinir un nouveau type de la manire suivante :
Type Livre =
record
Titre : String;
Auteur : String;
AnneePublication : Integer;
end ;
On a ainsi dfini un nouveau type de variable nomm Livre . Titre , Auteur et AnneePublication sont
les champs de ce type.
Les champs reprsentent les attributs du concept que l'on veut dfinir. Chaque champ est dfini par son type. Dans
notre exemple, Titre et Auteur sont des chanes de caractres et AnneePublication est un entier.
Dclaration de variables de type structur
partir du moment o un nouveau type a t dfini, il est possible de dclarer des variables de ce type. Une variable
de type structur est appele une structure ou un enregistrement. Cette dclaration se fait comme pour un type
prdfini.
Les bases de la programmation par Eric Thirion
- 108 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Par exemple, pour dclarer deux variables l1, l2 de type Livre, on crira :
Var l1, l2 : Livre;
Manipulation des champs d'une structure
Pour accder aux champs d'une structure, on utilise l'oprateur . .
Par exemple, pour affecter la valeur Visual Basic 6 Le Guide du programmeur au titre du livre l1, on crira :
l1.Titre := 'Visual Basic 6 - Le Guide du programmeur';
Un champ se manipule exactement comme une variable du mme type. Par exemple, l1.AnneePublication se
manipule exactement comme un entier. Pour obtenir l'ge du livre l1, on peut trs bien crire :
Var Age : Integer;
Age := AnneeActuelle - l1.AnneePublication;
Dfinition de types complexes par combinaison
Il est possible de dfinir des types complexes en combinant tableaux et structures, ou bien en combinant les types
structurs entre eux. Donnons quelques exemples.
Tableaux de structures : les tables
Le type des lments d'un tableau peut tre quelconque. On peut donc dfinir un tableau dont les lments sont des
types structurs, ou autrement dit un tableau de structures.
Les tableaux de structures sont galement appels tables. Ils jouent un rle important en informatique, puisqu'on les
retrouve dans les bases de donnes. Nous verrons ultrieurement qu'une base de donnes n'est rien d'autre qu'un
ensemble de tables stockes dans des fichiers.
Pour reprsenter l'ensemble des livres prsents dans une bibliothque, on peut par exemple utiliser un tableau dont
les lments sont de type Livre :
Var Bibliotheque : array [1..M] of Livre;
La variable Bibliotheque est donc un tableau de structures. La notation
Bibliotheque[6].Auteur
reprsente alors l'auteur du 6e livre.
Structure avec champs de type structur
Enrichissons un peu notre reprsentation d'un livre. Pour la gestion d'une bibliothque, il serait intressant d'associer
une date d'emprunt chaque livre :
Type Livre =
record
Titre : String;
Auteur : String;
AnneePublication : Integer;
DateEmprunt : TDate;
Les bases de la programmation par Eric Thirion
- 109 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
end;
Le type TDate tant lui-mme un type structur dfini par :
Type TDate =
record
Jour : Integer;
Mois : Integer;
Annee : Integer;
end;
Supposons que L soit une variable de type Livre. Pour dfinir la date d'emprunt de L, comme le 27 janvier 2009,
on crira :
L.DateEmprunt.Jour := 27;
L.DateEmprunt.Mois := 1;
L.DateEmprunt.Annee := 2009;
Les pointeurs
Dclaration d'un pointeur
Un pointeur est une variable contenant une adresse.
Rappelons (cf. le chapitre sur les premires notions) qu'une adresse est un entier qui reprsente la position d'un
octet en mmoire. Cet entier permet donc en particulier de reprer la position, ou autrement dit l'adresse, d'une plage
mmoire :
En Pascal, un pointeur se dclare de la manire suivante :
Var NomDuPointeur : ^Type;
o Type reprsente le type de donne dont le pointeur contiendra l'adresse.
Exemple :
Type Ville =
record
Nom : String;
CodePostal : Integer;
End;
Var PVille : ^Ville;
Dans cet exemple, la variable PVille est un pointeur sur une donne de type Ville.
Les bases de la programmation par Eric Thirion
- 110 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Une autre manire de dclarer un pointeur est de dfinir tout d'abord un type pointeur de la manire suivante :
Type PointeurSurType = ^Type;
et de dclarer ensuite le pointeur comme une variable de ce type :
Var NomDuPointeur : PointeurSurType;
Avec l'exemple prcdent cela donnerait :
Type Ville =
record
Nom : String;
CodePostal : Integer;
End;

PointeurSurVille = ^Ville;
Var PVille : PointeurSurVille;
Allocation dynamique de mmoire
Un pointeur permet de crer une variable sans nom, repre uniquement par l'adresse qu'il contient.
Cette variable est cre par un mcanisme d'allocation dynamique de mmoire, que nous allons dcrire prsent.
Les variables gnres dynamiquement sont stockes dans une zone spciale de la mmoire appele le tas (heap
en anglais).
En Pascal, l'allocation dynamique de mmoire se fait grce l'oprateur new.
Si p est un pointeur sur un type T, new(p) va allouer de la place mmoire dans le tas pour une variable de ce type
et affecter p l'adresse de cette variable.
Avec notre exemple prcdent, new(p) rserverait de la place pour une structure de type Ville et affecterait l'adresse
de cette structure p. Par exemple, si la plage mmoire rserve pour la structure commence l'adresse 1961, p
contiendra cette adresse :
Une fois que la variable est cre, il est possible d'y accder par l'oprateur ^. Si p est un pointeur, p^ reprsente
la variable pointe par p.
Avec notre exemple, pour affecter Strasbourg au nom de la ville point par p, on crirait :
Les bases de la programmation par Eric Thirion
- 111 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
p^.Nom := 'Strasbourg';
Tout se passe donc comme si p^ tait une variable de type Ville.
Listes simplement chanes
Pour l'instant, le seul moyen dont vous disposez pour reprsenter un ensemble de donnes est le tableau. Dans un
tableau, chaque donne (de mme type) possde un indice dfinissant sa position dans le tableau.
Les listes sont une autre manire de reprsenter un ensemble de donnes n'utilisant pas d'indice et base sur les
pointeurs.
Reprsentation
Une liste simplement chane se reprsente par un ensemble de structures de mme type
possdant un champ contenant l'adresse de l'lment suivant.
Il serait assez difficile et peu pdagogique de prsenter les listes chanes dans un cas gnral abstrait. Nous allons
donc baser toutes nos explications sur un exemple qui sera facile gnraliser : une liste de structures de type Ville
dont voici la dclaration :
Type
PVille = ^Ville;
Ville = record
Nom : String;
CodePostal : String;
Suivant : PVille;
end;
Le champ Suivant sert mmoriser l'adresse de l'lment suivant de la liste. Dans le cas gnral, il peut porter
n'importe quel nom, mais il doit exister un champ jouant ce rle.
La liste, quant elle, est galement un pointeur qui contient l'adresse de son premier lment.
Dans notre exemple, on pourrait donc reprsenter une liste de villes par une variable L de type PVille.
Voici par exemple une liste simplement chane contenant quatre villes :
L contient l'adresse de la premire ville (Ribeauvill). Le champ Suivant de la premire ville contient l'adresse de
la seconde (Kingersheim), etc.
Le dernier lment de la liste (Nancy) n'a pas d'lment suivant. Son champ Suivant contient la valeur NIL, qui
reprsente en Pascal une adresse inexistante.
Une liste vide se reprsente simplement par un pointeur de liste gal NIL (L = NIL dans notre
exemple).
Les bases de la programmation par Eric Thirion
- 112 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Parcours
Pour effectuer un traitement sur chaque lment d'une liste, il est ncessaire de savoir parcourir ses lments. On
utilisera pour cela un pointeur, qui prendra successivement la valeur des adresses de chaque lment de la liste.
Voici par exemple comment parcourir une liste de villes dont l'adresse est contenue dans le pointeur L :
Var p : Pville;
p := L;
While p <> NIL Do
begin
{ Traitement de l'lment point par p }
p := p^.Suivant;
end;
Adjonction d'un lment
Considrons le problme suivant : on dispose d'une liste de villes L et d'une structure de type Ville pointe par un
pointeur p. Comment procder pour ajouter cette structure dans la liste ?
En dbut de liste
Pour ajouter l'lment p^ au dbut de la liste L, il suffit de faire :
p^.Suivant := L;
L := p;
La premire affectation accroche la structure la liste et la deuxime met jour l'adresse de la liste, qui devient
celle de p.
Cette mthode fonctionne galement avec une liste vide. En effet, dans ce cas L vaut NIL
avant l'adjonction. Aprs l'adjonction, on aura bien une liste d'un lment (p^) avec L = p et
p^.Suivant = NIL.
La figure suivante illustre l'adjonction en dbut de liste de la ville Ribeauvill :
Avant l'adjonction :
la liste L contient les trois villes Kingersheim, Strasbourg et Nancy ;
L contient l'adresse de la structure reprsentant Kingersheim.
Les bases de la programmation par Eric Thirion
- 113 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Aprs l'adjonction :
le champ Suivant de la structure reprsentant Ribeauvill contient l'adresse de la structure reprsentant
Kingersheim ;
L contient l'adresse de la structure reprsentant Ribeauvill ;
L contient donc prsent les quatre villes Ribeauvill, Kingersheim, Strasbourg et Nancy.
Insertion aprs un lment
Supposons prsent que la liste n'est pas vide et que l'on souhaite insrer un lment aprs un certain lment
de la liste.
Soit p l'adresse du nouvel lment que l'on souhaite insrer, et Curseur l'adresse de l'lment aprs lequel on
souhaite insrer p^. Les instructions suivantes permettent d'obtenir ce que l'on souhaite :
p^.Suivant := Curseur^.Suivant;
Curseur^.Suivant := p;
La figure suivante illustre l'insertion d'une structure reprsentant Strasbourg, aprs la structure reprsentant
Kingersheim :
Suppression d'un lment
Suppression du premier lment
Pour supprimer le premier lment d'une liste simplement chane, il suffit de remplacer l'adresse de la liste par
l'adresse de l'lment qui suit le premier.
Avec notre exemple, cela se traduit par l'instruction suivante :
L := L^.Suivant;
Si la liste ne contient qu'un seul lment, ce dernier n'a pas d'lment suivant, mais l'instruction
prcdente convient galement, car, dans ce cas, L^.Suivant contient NIL et la liste devient
par consquent vide.
La figure suivante illustre la suppression du premier lment dans une liste de villes :
Les bases de la programmation par Eric Thirion
- 114 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Avant la suppression, L pointe sur Ribeauvill et la liste contient quatre villes.
Aprs la suppression, L pointe sur la ville qui suivait Ribeauvill, c'est--dire Kingersheim. De ce fait, elle ne contient
plus que les trois villes Kingersheim, Strasbourg et Nancy.
Suppression du suivant
Supposons prsent que l'on souhaite supprimer l'lment qui suit un certain lment de la liste d'adresses donne.
Appelons Curseur l'adresse de cet lment. L'instruction suivante permet de supprimer l'lment qui suit Curseur^ :
Curseur^.Suivant := Curseur^.Suivant^.Suivant;
La figure suivante illustre ce mcanisme. On supprime ici la ville Strasbourg, en faisant pointer la ville prcdente
(Kingersheim) sur la ville qui suit Strasbourg (Nancy). De ce fait, Strasbourg n'existe plus dans la liste.
Listes doublement chanes
Dans une liste doublement chane, chaque lment est li non seulement au suivant, mais galement au prcdent.
Cela facilite la suppression d'un lment, puisqu'il faut pour cela avoir l'adresse du prcdent. Il devient galement
plus simple d'insrer un lment avant un lment donn.
Reprsentation
Reprenons notre exemple de liste de villes. Voici comment la reprsenter avec un chanage double :
Type Ville =
record
Nom : String;
CodePostal : String;
Suivant : PVille;
Les bases de la programmation par Eric Thirion
- 115 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Precedent : Pville;
end;
PVille = ^Ville;
Voici un exemple de liste doublement chane :
Adjonction d'un lment
En dbut de liste
L'adjonction d'un lment en dbut de liste ncessite deux instructions supplmentaires, puisqu'il faut mmoriser le
fait que cet lment n'a pas d'lment prcdent et qu'il devient prsent le prcdent du premier lment de la
liste (avant l'adjonction).
p^.Suivant := L ;
p^.Precedent := NIL;
L^.Precedent := p;
L := p;
Insertion aprs un lment
If Curseur^.Suivant <> NIL then
Curseur^.Suivant^.Precedent := p;
p^.Precedent := Curseur;
p^.Suivant := Curseur^.Suivant;
Curseur^.Suivant := p;
Exercices
Tlchargez :

les exercices sur les types structurs ;

les exercices sur les pointeurs et les listes.


Pour obtenir les corrigs, le tlchargement n'est possible que via un login et un mot de passe, que vous pouvez
obtenir en envoyant un mail l'adresse suivante :
Les bases de la programmation par Eric Thirion
- 116 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
en prcisant un peu qui vous tes et les raisons pour lesquelles ce cours vous intresse.
Les fichiers
But de ce chapitre
En utilisant ce que nous avons vu dans les cours prcdents, vous ne pouvez pas raliser un programme qui serait
capable de conserver ses rsultats une fois l'ordinateur teint. D'autre part, les donnes doivent tre ncessairement
fournies par l'utilisateur chaque excution du programme. Ces limitations proviennent du type de mmoire utilis :
pour l'instant, vous ne savez traiter que des donnes stockes en mmoire vive. Or, la mmoire vive est volatile :
lorsque l'ordinateur est mis hors tension, tout disparat !
Ce problme pourrait donc tre donc rsolu si vous connaissiez les instructions permettant de lire ou d'enregistrer
des donnes dans des mmoires non volatiles, stockes par exemple sur le disque dur ou sur une cl USB, sous
la forme de fichiers.
L'objectif de ce cours est de vous dcrire prcisment les procdures Pascal ralisant ceci.
Notion de fichier
Qu'est-ce qu'un fichier ?
Un fichier est un ensemble de donnes informatiques stockes en mmoire auxiliaire
(disque dur, CD, DVD, clef USB) possdant un nom, un chemin d'accs et gnralement
implicitement associ un format (format image, format de documents, formats de base de
donnes).
Le terme de mmoire auxiliaire dsigne tout support de stockage de l'information d'un
ordinateur autre que la mmoire vive.
Le fait qu'un fichier soit toujours stock sur mmoire auxiliaire a deux consquences.
Premirement, les donnes contenues dans un fichier ne sont pas perdues lorsque l'ordinateur est mis hors tension
(contrairement aux donnes contenues dans les variables d'un programme !).
Deuximement, l'accs des donnes stockes dans un fichier est considrablement plus lent qu'un accs des
donnes contenues en mmoire vive.
Nom de fichier
La manire de nommer les fichiers dpend fortement du systme d'exploitation. Par exemple, sous Windows, tout
fichier possde gnralement une extension (.doc, .jpg) qui permet d'identifier son format.
Les bases de la programmation par Eric Thirion
- 117 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Chemin d'accs
Le chemin d'accs d'un fichier dfinit sa localisation sur un priphrique donn. C'est une
chane de caractres qui dfinit la suite des rpertoires parcourir pour atteindre le fichier
depuis la racine du priphrique.
La manire de dcrire un chemin dpend du systme d'exploitation. Sous Windows, un chemin est une chane de
caractres de la forme :
X:\Rpertoire\Rpertoire\ ... \Rpertoire
o X est une lettre dfinissant le priphrique utilis.
Par exemple :
C:\Utilisateurs\Thirion\Documents
Identification d'un fichier par son nom complet
Le nom d'un fichier ne l'identifie pas de manire unique. Par exemple, il peut exister un fichier nomm CV.doc sous
C:\Utilisateurs\Thirion\Documents
et un autre sous
C:\Utilisateurs\Einstein\Documents
Pour identifier un fichier de manire unique, il faut utiliser son chemin concatn avec le nom (simple) du fichier.
Par exemple :
C:\Utilisateurs\Thirion\Documents\CV.doc
dsigne le CV de Thirion, alors que :
C:\Utilisateurs\Einstein\Documents\CV.doc
dsigne le CV de Einstein.
J'utiliserai par la suite le terme de nom complet, pour dsigner le chemin concatn avec le nom du fichier.
Format
Le format d'un fichier est un ensemble de conventions dfinissant la reprsentation des
donnes qu'il contient : la localisation et le codage des diffrents types d'informations contenues
dans le fichier.
Le fichier en lui-mme ne permet pas coup sr de retrouver son format de manire immdiate : comme toute chose
en informatique, ce n'est qu'une suite de zros et de uns. Une manire de vrifier si un fichier est bien dans un format
donn est de l'ouvrir avec un logiciel adapt ce format. Si le logiciel gre correctement le fichier, il est certainement
dans le bon format (mais ce n'est pas une certitude !). Une autre manire est de scruter l'en-tte du fichier la
recherche d'une signature numrique propre son format.
Les bases de la programmation par Eric Thirion
- 118 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Exemple : si je peux ouvrir un fichier avec Word, il s'agit trs certainement d'un fichier respectant un des formats
accepts par Word (.doc, .txt). Au contraire, si j'essaie d'ouvrir avec Word un fichier qui n'est pas dans un format
accept par Word, il se produira probablement n'importe quoi.
Sous Windows, le format d'un fichier est reprable par l'extension (.doc pour un fichier Word, .exe pour un fichier
excutable). Mais l'extension d'un fichier peut tre change manuellement L'extension d'un fichier ne donne
donc aucune certitude sur son format !
Les fichiers texte
Les fichiers texte sont des fichiers que l'on peut ouvrir avec un diteur de texte (comme
WordPad ou le Bloc-notes) afin de modifier leur contenu.
Ce sont par exemple les fichiers d'extension .txt sous Windows, les fichiers sources d'un programme, les fichiers
HTML, etc.).
Un fichier texte est un fichier qui peut tre interprt comme une suite de caractres (le plus souvent en code ASCII)
affichables l'cran.
Deux caractres spciaux servent coder le passage la ligne et la fin du fichier.
Les fichiers structurs
Les fichiers structurs sont des fichiers interprtables comme une suite d'enregistrements
d'un certain type. Tous les enregistrements sont forcment de mme taille.
Les fichiers structurs peuvent tre vus comme la reprsentation d'un tableau en mmoire auxiliaire. Rappelez-
vous que tous les lments d'un tableau doivent tre de mme type. Les lments du tableau correspondent ici aux
enregistrements.
Certains auteurs utilisent le nom de fichiers squentiels pour dsigner des fichiers structurs. Je trouve ce nom trs
mal adapt car il porte confusion. Nous verrons pourquoi un peu plus loin.
Oprations sur les fichiers
Les langages de programmation permettent de :
crer des fichiers ;
enregistrer des informations dans un fichier : c'est l'accs en criture ;
lire des informations dans un fichier : c'est l'accs en lecture.
Les erreurs d'accs
Le systme d'exploitation est responsable de la gestion des fichiers d'un ordinateur. Toute opration sur un fichier se
fait donc ncessairement par l'intermdiaire du systme d'exploitation. Lorsqu'un programme effectue une opration
sur un fichier, il faut que le systme d'exploitation autorise cette opration, sans quoi il se produira une erreur d'accs :
Les bases de la programmation par Eric Thirion
- 119 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Voil quelques-unes des erreurs les plus frquentes :
vous faites un accs en lecture sur un fichier qui n'existe pas ;
vous faites un accs en lecture sur un fichier, alors que vous n'avez pas de droit de lecture sur ce fichier : ce
fichier appartient un autre utilisateur, c'est un fichier protg, etc. ;
vous faites un accs en criture sur un fichier, alors que vous n'avez pas de droit d'criture sur ce fichier ;
vous faites un accs en criture sur un fichier alors qu'un autre programme est en train d'y accder en lecture
ou en criture ;
vous faites un accs en criture sur un fichier alors que le priphrique qui le contient est plein ;
vous faites un accs en lecture ou en criture en dehors du fichier.
Ouverture et fermeture d'un fichier
L'accs un fichier par programmation fonctionne toujours selon le mme principe :
avant de lire ou d'crire des informations dans un fichier, il faut l'ouvrir ;
lorsque le traitement du fichier est termin il faut le fermer.
quoi sert l'ouverture d'un fichier ?
Ouvrir un fichier sert (entre autres) informer le systme d'exploitation que l'on a l'intention d'y accder. C'est ce
moment-l que le systme peut refuser l'accs au fichier, ce qui provoquera une erreur d'excution du programme.
quoi sert la fermeture d'un fichier ?
La fermeture d'un fichier sert (entre autres) signaler au systme d'exploitation que le fichier n'est plus utilis par le
programme, ce qui permettra un autre programme (ventuellement d'un autre utilisateur) d'y accder.
Les bases de la programmation par Eric Thirion
- 120 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Accs direct et accs squentiel
Il y a deux manires d'accder un fichier par programmation : l'accs direct et l'accs squentiel.
Accs direct
L'accs direct n'est possible que pour des fichiers dfinis comme une suite de blocs de taille fixe que l'on appelle
enregistrements. Il n'est donc possible que pour les fichiers structurs.
L'accs direct signifie qu'il est possible d'accder directement un enregistrement partir de sa position dans le
fichier : lire le nime enregistrement du fichier ou le modifier. Ce type d'accs est par exemple adapt la gestion
des tables d'une base de donnes.
Accs squentiel
Dans l'accs squentiel, une opration de lecture ou d'criture se fait toujours juste aprs la dernire partie du fichier
lue ou crite.
Les bases de la programmation par Eric Thirion
- 121 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Les fichiers texte n'autorisent que ce type d'accs.
Les fichiers structurs quant eux autorisent les deux types d'accs (squentiel ou direct).
Vous comprenez prsent pourquoi le fait d'appeler fichiers squentiels les fichiers
structurs est une source de confusion !
Manipulation des fichiers texte
Ouverture d'un fichier texte
L'ouverture d'un fichier texte se fait en lecture, en criture ou en ajout. Nous ne traiterons pas ici de l'ouverture en ajout.
Si le fichier est ouvert en lecture, il ne peut y avoir que des lectures jusqu' la fermeture du fichier.
De mme, si le fichier est ouvert en criture, il ne peut y avoir que des critures jusqu' la fermeture du fichier.
Les bases de la programmation par Eric Thirion
- 122 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Oprations sur les lignes
Un fichier texte est normalement organis en lignes. Les langages de programmation contiennent en gnral une
instruction (ou une procdure) permettant de :
lire une ligne du fichier en la recopiant dans une variable de type chane de caractres. Cette opration n'est
possible que si le fichier est ouvert en lecture. De plus, comme il s'agit d'un accs squentiel, elle se fait
forcment juste aprs la dernire ligne lue. Sauf si le fichier vient d'tre ouvert. Dans ce cas, la ligne lue est
ncessairement la premire ligne du fichier ;
crire une chane de caractres dans une ligne du fichier. De mme, cette opration n'est possible que si le
fichier est ouvert en criture et se fait forcment juste aprs la dernire ligne crite. Exception pour l'criture
d'une ligne qui suit immdiatement l'ouverture du fichier : ce sera forcment la premire ligne du fichier.
Manipulation des fichiers structurs
Ouverture d'un fichier structur
Pour ouvrir un fichier structur, il n'est pas ncessaire de prciser si l'on veut ouvrir le fichier en lecture ou en criture.
En effet, avec un fichier structur, ces deux types d'oprations (lecture et criture) peuvent tre mlanges dans
n'importe quel ordre.
Si le fichier n'existe pas avant l'ouverture, il sera cr.
Accs squentiel
L'accs squentiel dans un fichier structur consiste lire ou crire un enregistrement sans prciser sa position.
La lecture ou l'criture se fait ncessairement juste aprs le dernier enregistrement lu ou crit. Sauf si le fichier vient
juste d'tre ouvert. Dans ce cas, l'enregistrement lu ou crit sera forcment le premier.
Accs direct
Dans l'accs direct, on accde un enregistrement par sa position dans le fichier. Il est par exemple possible de lire
le 25e enregistrement, puis de modifier le 122e. On peut parcourir le fichier dans n'importe quel ordre.
Manipulation de fichiers texte en Pascal
Dclaration
Un fichier texte est reprsent en Pascal par le type TextFile. Pour pouvoir manipuler un fichier texte, il faut d'abord
dclarer une variable de ce type. Par exemple :
var f : TextFile;
Dans toutes les explications qui suivent, f dsignera le fichier dclar de cette manire.
Assignation
Avant de pouvoir ouvrir un nouveau fichier texte, il faut d'abord associer la variable fichier au nom du fichier sur
le disque. Cela se fait par la procdure AssignFile. Voici, par exemple, comment associer f un fichier nomm
exemple.txt :
Les bases de la programmation par Eric Thirion
- 123 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
AssignFile(f,'exemple.txt');
Cration d'un fichier texte
Ouverture en criture
Aprs avoir dclar une variable de type fichier et assign cette variable un nom de fichier, on peut l'ouvrir en
criture. Cela a pour effet de crer un nouveau fichier vide. Attention : s'il existe dj un fichier de mme nom sur
le disque, le contenu de ce dernier sera perdu !
L'ouverture en criture, se fait par la procdure rewrite, comme suit :
rewrite(f);
criture d'une ligne
Ds que le fichier est ouvert en criture, on peut y crire du texte en utilisant la procdure writeln. Voici, par exemple,
comment crer un fichier texte exemple.txt d'une ligne :
var f: TextFile;
begin
assign (f,'exemple.txt');
rewrite(f);
writeln (f,'Ceci est un fichier d'une ligne.');
CloseFile(f);
end;
La procdure CloseFile appele la fin sert fermer le fichier.
Comme on fait de l'accs squentiel, une criture se fait forcment aprs la ligne crite juste avant. Donc, aprs
l'excution du code suivant :
var f: TextFile;
begin
assign(f,'exemple.txt');
rewrite(f);
writeln(f,'Premire ligne du fichier exemple.txt');
writeln(f,'Deuxime ligne du fichier exemple.txt');
CloseFile(f);
end;
le fichier exemple.txt contiendra les deux lignes :
Premire ligne du fichier exemple.txt
Deuxime ligne du fichier exemple.txt
Lecture d'un fichier texte
Ouverture d'un fichier texte en lecture
Pour ouvrir un fichier en lecture, on utilise la procdure reset de la manire suivante :
reset(f);
Les bases de la programmation par Eric Thirion
- 124 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Comme pour l'ouverture en criture, il faut que le fichier ait auparavant t assign un nom de fichier. Par contre,
si ce fichier n'existe pas, cela provoquera une erreur.
Lecture d'une ligne et test de fin de fichier
Pour lire une ligne dans le fichier, on utilise la procdure readln, qui affecte la ligne courante une variable L de
type chane de caractres :
readln(f,L);
Il s'agit ici d'un accs squentiel, donc une lecture de ligne se fait ncessairement juste aprs la ligne lue
prcdemment.
Juste aprs l'ouverture du fichier, readln transfre la premire ligne du fichier dans variable L.
la deuxime excution de cette procdure, L contiendra la 2e ligne du fichier et de manire gnrale, aprs la
nime excution, L contiendra la nime ligne du fichier.
Bien entendu, on provoquera une erreur d'excution si l'on essaie de lire au-del de la fin du fichier. Par exemple, si
le fichier exemple.txt ne contient que 10 lignes, la 11e excution de readln(f,L); provoquera une erreur d'excution.
Pour viter cette erreur, il faut utiliser la fonction eof, qui permet de tester si l'on se trouve en fin de fichier. Par
exemple, le code suivant permet de lire toutes les lignes du fichier exemple.txt afin d'effectuer un certain traitement
sur chaque ligne :
Var f : TextFile; L : String;
begin
assign(f,'exemple.txt');
reset(f);
while not eof(f) do
begin
readln(f,L);
// Traitement de la ligne L
end;
CloseFile(f);
end;
Les fichier structurs en Pascal
Dclaration
Un fichier structur est un fichier constitu d'enregistrements de mme type.
Le type d'un enregistrement est a priori n'importe quel type Pascal de taille fixe. En effet, comme chaque
enregistrement doit occuper la mme taille en mmoire auxiliaire, on ne peut pas dclarer un fichier constitu
d'enregistrements de longueur variable. En particulier, le type String sera interdit et devra tre remplac par le type
String[n], qui permet de prciser la taille de la chane de caractres.
Pour la suite des explications, nous allons utiliser le type structur Livre dclar comme suit :
Livre =
record
Titre : String[100];
Auteur : String[20];
AnnePub : integer;
Les bases de la programmation par Eric Thirion
- 125 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
end;
Nous pouvons ensuite dclarer un fichier structur compos d'enregistrements de type Livre comme suit :
var f : file of Livre;
Remarquez que le type des enregistrements d'un fichier structur n'est pas forcment un type
structur. On peut par exemple dclarer un fichier d'entiers (file of integer) ou un fichier de
caractres (file of char).
Assignation
Tout comme pour les fichiers texte, avant d'ouvrir un fichier structur il faut associer la variable reprsentant le fichier
un nom de fichier avec la procdure AssignFile.
Exemple :
AssignFile(f,'Bibliotheque.dat');
Cette instruction assigne f au fichier de nom Bibliotheque.dat.
Ouverture et fermeture
Pour ouvrir des fichiers structurs, on utilise encore les procdures reset et rewrite. Mais elles n'ont pas la mme
signification que pour les fichiers texte.
En effet, il sera toujours possible de lire et d'crire des enregistrements, que le fichier soit ouvert avec reset (ouverture
en lecture pour un fichier texte) ou avec rewrite (ouverture en criture pour un fichier texte).
Pour les fichiers structurs, rewrite n'est pas une ouverture en criture. Cela signifie seulement que l'on demande au
systme d'exploitation de crer un nouveau fichier. Avec reset, on demande simplement l'ouverture, sans cration
d'un nouveau fichier.
Par contre, un fichier ne peut pas tre ouvert avec reset s'il n'existe pas. Pour ouvrir un fichier structur sans savoir
auparavant s'il existe ou non, on utilisera la fonction FileExists (fonction permettant de tester l'existence d'un fichier
de nom donn) de la manire suivante :
if FileExists('Bibliotheque.dat') then
reset(f)
else
rewrite(f);
criture squentielle
L'criture d'un enregistrement se fait avec la procdure write. Plus prcisment, write (f,v) crit la valeur de la
variable v dans le fichier f la suite du dernier enregistrement lu ou crit. Bien entendu, la variable doit tre de mme
type que les enregistrements du fichier.
Si le fichier vient d'tre ouvert, l'criture se fait dans le premier enregistrement.
Dclarons par exemple deux structures de type Livre :
var VB, Gaston : Livre;
Les bases de la programmation par Eric Thirion
- 126 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
Donnons des valeurs leurs champs :
VB.Titre := 'Visual Basic 6, Le guide du programmeur';
VB.Auteur := 'Frantz';
VB.AnneePub := 2000;
Gaston.Titre := 'Gaston Lagaffe - Des Gaffes et des Dgts';
Gaston.Auteur := 'Franquin';
Gaston.AnneePub := 1975;
Aprs les instructions suivantes :
AssignFile(f,'Bibliotheque.dat');
rewrite(f);
write(f,Gaston);
write(f,VB);
le fichier Bibliotheque.dat contiendra deux enregistrements de type Livre. Plus prcisment, le premier
enregistrement contiendra le livre Gaston et le deuxime, le livre VB.
Si, aprs cela, on fait encore une fois
write(f,Gaston);
le fichier contiendra trois enregistrements (Gaston, VB, Gaston).
Si on crit un enregistrement juste aprs l'ouverture d'un fichier existant (donc avec un reset), cette criture se fera
dans le premier enregistrement du fichier. Par exemple, aprs l'excution du code suivant :
AssignFile(f,'Bibliotheque.dat');
reset(f);
write(f, VB);
le fichier contiendra (VB, VB, Gaston).
Lecture squentielle
La lecture d'un enregistrement la suite du dernier enregistrement lu ou crit se fait par la procdure read. Plus
prcisment, pour affecter la valeur d'un enregistrement une variable v, on crira read(f,v). Cela suppose bien
entendu que la variable est du mme type que les enregistrements du fichier.
Si le fichier vient d'tre ouvert, l'enregistrement lu sera le premier.
Reprenons la suite de l'exemple prcdent. Notre fichier Bibliotheque.dat contient prsent trois enregistrements
de type Livre (VB, VB, Gaston).
Pour les rcuprer, dclarons trois variables de type Livre :
var Livre1, Livre2, Livre3 : Livre;
Aprs les instructions suivantes :
AssignFile(f,'Bibliotheque.dat');
reset(f);
read(f,Livre1);
read(f,Livre2);
read(f,Livre3);
Les bases de la programmation par Eric Thirion
- 127 -
Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre convenance. Par contre, la page de
prsentation constitue une uvre intellectuelle protge par les droits d'auteur. Copyright 2014 Eric Thirion. Aucune reproduction,
mme partielle, ne peut tre faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation
expresse de l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages et intrts.
http://lazarus.developpez.com/cours/eric-thirion/bases-programmation/
les structures Livre1 et Livre2 contiendront le livre VB et Livre3 contiendra le livre Gaston.
Lecture jusqu'en fin de fichier
De manire gnrale, on ne connat pas le nombre d'enregistrements contenus dans un fichier structur. On utilise
alors la fonction eof pour savoir si on est arriv la fin du fichier. Voici comment lire squentiellement un fichier
structur afin d'effectuer un traitement sur chacun de ses enregistrements :
var f : file of type;
x : type;
AssignFile(f,'Bibliotheque.dat');
reset(f);
while not eof(f) do
begin
read(f,x);
// Traitement de l'enregistrement x
end;
Exercices
Tlchargez les exercices sur le site de l'auteur :

Exo-Fichiers-Pascal.pdf
Pour obtenir les corrigs, le tlchargement n'est possible que via un login et un mot de passe, que vous pouvez
obtenir en envoyant un mail l'adresse suivante :
en prcisant un peu qui vous tes et les raisons pour lesquelles ce cours vous intresse.