COURS Programmation

T1IF
BEISI'03 => ROTFA'05 => FISRO'06
Informatique
Gnrale
INFormatique GEnrale
Version 16/10/2006
Page 1/33
T1IF
Table des matires

1. Les caractres....................................................................................................3
1.1. Dclaration d'une variable.............................................................................3
1.2. Oprations dfinies sur le type char................................................................3
1.2.1. L'affectation :=..................................................................................................................3
1.2.2. Les oprateurs de comparaison =, <, <=, >=, >, <>.............................................................3
1.3. Fonctions associes au type char...................................................................5

1.3.1. La fonction chr...................................................................................................................5
1.3.2. La fonction ord..................................................................................................................5
1.3.3. La fonction upcase.............................................................................................................5
2. Les chanes de caractres (textes)........................................................................6

2.1. Dclaration d'une variable ou constante..........................................................6
2.2. Reprsentation d'une variable du type string...................................................6
2.3. Oprations dfinies sur le type string..............................................................8
2.3.1. L'affectation :=..................................................................................................................8
2.3.2. Les oprateurs de comparaison =, <, <=, >=, >, <>.............................................................8
2.3.3. L'oprateur + pour concatner 2 chanes...............................................................................8
2.4. Procdures et fonctions associes au type string..............................................9

2.4.1.
2.4.2.
2.4.3.
2.4.4.
2.4.5.
2.4.6.
2.4.7.
La
La
La
La
La
La
La
fonction length..............................................................................................................9
fonction pos..................................................................................................................9
procdure delete............................................................................................................9
procdure insert............................................................................................................9
fonction copy...............................................................................................................10
procdure strtoint........................................................................................................10
procdure inttostr........................................................................................................11
2.5. Compatibilit entre char et string.................................................................11

3. Tableau une dimension (Array).........................................................................12
3.1. Dfinition..................................................................................................12
3.2. Dclaration d'un tableau.............................................................................12
3.2.1. Remarques......................................................................................................................12
3.3. Accs aux lments d'un tableau..................................................................14

3.3.1. Remarque.......................................................................................................................14
3.4. Remplir un tableau avec des valeurs.............................................................14

3.4.1. Affectation par :=............................................................................................................14
3.4.2. Affectation par lecture.......................................................................................................15
4. Tableau plusieurs dimensions...........................................................................16

4.1. Dclaration d'un tableau plusieurs dimensions.............................................16
4.2. Accs aux lments....................................................................................17
5. Sous-Programmes.............................................................................................18
5.1. Procdures................................................................................................18
5.1.1. Dclaration d'une procdure..............................................................................................18
5.1.2. Appel d'une procdure......................................................................................................19
5.1.3. Structogramme................................................................................................................19
5.2. Fonctions..................................................................................................21
5.2.1. Dclaration d'une fonction.................................................................................................21
5.2.2. Appel d'une fonction.........................................................................................................22
5.2.3. Structogramme................................................................................................................22
5.3. La notion de porte de variable....................................................................24

5.3.1. Variables ou constantes locales..........................................................................................24
5.3.2. Variables ou constantes globales........................................................................................24
5.4. Sous-programmes avec paramtres..............................................................26

5.5. Transmission des paramtres.......................................................................27
6. Enregistrements...............................................................................................29
6.1. Dclaration d'un enregistrement..................................................................30
6.1.1. Dclaration d'une variable.................................................................................................30
6.1.2. Dclaration d'un nouveau type...........................................................................................31
6.2. Utilisation d'un enregistrement....................................................................31

6.2.1. Imbrications d'enregistrements..........................................................................................32
6.2.2. Tableau d'enregistrements.................................................................................................32
Version 16/10/2006
Page 2/33
T1IF
1.
Les caractres
Outre les types de donnes numriques, comme integer, real, ..., on dispose, dans les
langages de programmation volus, de types de donnes permettant de reprsenter des
caractres et des chanes de caractres.
En Pascal le type char correspond un seul caractre (lettre, chiffre, caractre
spcial,...) du code ASCII (American Standard Code for Information Interchange). Une
variable du type char occupe un byte dans la mmoire, ce qui explique l'existence de
256 caractres diffrents, dont chacun est identifi par un code.
char est comme integer, boolean un type ordinal, c'est--dire que chaque caractre a
un prdcesseur (Vorgnger) unique et un successeur (Nachfolger) unique.
1.1.
Dclaration d'une variable
var
C1,C2,C3:char;
1.2.
Oprations dfinies sur le type char
1.2.1.
L'affectation :=
Exemples:
C1:='!';
C2:='?';
C3:='N';
Par l'affectation le code ASCII du caractre affect est sauvegard dans la variable.
Exemple
Le code dcimal 78 est stock dans la cellule mmoire reprsentant la variable C3.
1.2.2.
Les oprateurs de comparaison =, <, <=, >=, >, <>
L'ordre est dfini par la position des codes dans la table ASCII.
Exemples:
'a' > 'A'
, car ..........................................................................................
'?' < 'A'
, car ..........................................................................................
Version 16/10/2006
Page 3/33
T1IF

Interpretation
null
start of heading
start of text
end of text
end of transmission
enquiry
acknowledge
bell
backspace
horizontal tab
new line
vertical tab
new page
carriage return
shift out
shift in
data link escape
device control 1
device control 2
device control 3
device control 4
negative acknowledge
synchronous idle
end of trans. block
cancel
end of medium
substitute
escape
file separator
group separator
record separator
uni separator
space
Code Char
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
0
1
2
3
Code Char
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
4
5
6
7
8
9
Code Char
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
Version 16/10/2006
Code Char
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
Code Char
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
Page 4/33
T1IF
1.3.
1.3.1.
Fonctions associes au type char

La fonction chr
Syntaxe: function chr(B:byte):char;
jbhbhhvg bvnvbbnbnbvnbvnbnbnbbv
mjhmjm
mkkk
Cette fonction prend comme entre un byte et donne le caractre correspondant suivant
le code ASCII en sortie.
Exemple:
C:=chr(65);
writeln(C);
1.3.2.
{ l'cran la lettre 'A' est affiche }
La fonction ord
Syntaxe: function ord(C:char):byte;

Cette fonction prend comme entre un char et donne son code ASCII correspondant en
sortie.
Exemple:
B:=ord('A');
writeln(B);
{ l'cran la valeur 65 est affiche }
fonction chr
code ASCII
(byte)
symbole
(char)
fonction ord
1.3.3.
La fonction upcase
Syntaxe: function upcase(C:char):char;

Cette fonction prend comme entre un char et donne comme rsultat la lettre majuscule
de l'alphabet correspondant l'entre C. La fonction ne convertit pas de caractres tels
que: , , , , ,
Exemple:
C:=upcase('r');
writeln(C)
{ l'cran la lettre 'R' est affiche }
Version 16/10/2006
Page 5/33
T1IF
2.
Les chanes de caractres (textes)
Une chane de caractres est une suite de caractres. En Pascal il s'agit du type string.
Dans l'environnement Turbo Pascal, la longueur maximale a t dfinie lors de la
dclaration et pouvait varier entre 1 et 255 caractres. La taille par dfaut tait de 255
caractres.
Sous Delphi, la taille d'un string est dynamique et peut varier entre 0 et 231 (=2GB!!!)
caractres.
2.1.
Dclaration d'une variable ou constante
const
var
2.2.
REPONSE='oui';
PHRASE:string;
MOT:string[10];
{ dclaration avec taille dynamique }

{ dclaration avec taille fixe }
Reprsentation d'une variable du type string
Chaque variable du type string peut tre reprsente comme tant une grille dans
laquelle on crit des caractres. De cette faon on peut aussi accder un caractre
prcis d'une chane en indiquant le nom de la chane suivi de la position (index) du
caractre.
Exemple:
En se basant sur les dclarations ci-dessus, la variable MOT (taille fixe 10) peut tre
reprsente de la manire suivante:
Position
10
MOT
Supposons qu'on excute ensuite l'instruction:
MOT:='pascal';
Alors la reprsentation change de la manire suivante:

Position
10
MOT
L'instruction writeln(MOT[2]); affiche la lettre 'a' l'cran.
Autre exemple:
PHRASE:='Salut Pascal!';
MOT:=PHRASE[1]+PHRASE[7];
writeln(MOT);
{ le texte 'SP' est affich }
Question:
Que se passerait-il si on excutait maintenant l'instruction writeln(MOT[3]); ?
Version 16/10/2006
Page 6/33
T1IF
............................................................................................................................
Version 16/10/2006
Page 7/33
T1IF
2.3.
Oprations dfinies sur le type string
2.3.1.
L'affectation :=
MOT:='NON';
PHRASE:='Il fait beau.';
MOT:='';
Si une chane contient un apostrophe, il faut le ddoubler;
Exemple:
PHRASE := 'l''affectation';
2.3.2.
Les oprateurs de comparaison =, <, <=, >=, >, <>
Les oprateurs de comparaison se portent sur la longueur de la chane de caractres. Si

les deux chanes ont la mme longueur, la premire position dans laquelle les deux
chanes se distinguent (code ASCII) dcide de l'ordre lexicographique des deux chanes.
Exemples:
'C++' ...
'Pascal'
, car ..................................................................
'Pas' ...
'Pascal'
, car ..................................................................
'pasc'...
'Pasc'
, car ..................................................................
2.3.3.
L'oprateur + pour concatner 2 chanes.
Exemple:
PHRASE:='Ceci est une belle ';
PHRASE:=PHRASE+'voiture';
writeln(PHRASE);
{ affiche 'Ceci est une belle voiture' }
Version 16/10/2006
Page 8/33
T1IF
2.4.
Procdures et fonctions associes au type string
En Pascal il existent plusieurs procdures et fonctions qui permettent de manipuler des

chanes de caractres.
2.4.1.
La fonction length
Syntaxe: function length(S:string):integer;

Cette fonction donne la longueur actuelle de la chane S.
Exemple:
NOM:='Muller';
L:=length(NOM);
writeln(L);
2.4.2.
{ affiche 6 }
La fonction pos
Syntaxe: function pos(SUBST:string; S:string):integer;

Cette fonction renvoie la position de la premire instance de SUBST dans S. Si SUBST ne
se trouve pas dans S, alors la fonction renvoie la valeur 0.
Exemples:
NOM:='Muller';
P:=pos('ller',NOM);
writeln(P);
{ affiche 3}
P:=pos('K',NOM);
writeln(P);
{ affiche 0 }
2.4.3.
La procdure delete
Syntaxe: procedure delete(var S:string; INDEX,COUNT:integer);

Cette procdure supprime de la chane S exactement COUNT caractres partir de la
position INDEX inclusive.
Exemple:
NOM:='Schmidt Leoni';
delete(NOM,8,5);
writeln(NOM);
{ affiche 'Schmidti' }
2.4.4.
La procdure insert
Syntaxe: procedure insert(SOURCE:string; var S:string; INDEX:integer);

Cette procdure insre la chane SOURCE dans la chane S partir de la position INDEX.
Exemple:
NOM:='Schmidt';
insert('ulze-Ch',NOM,4);
writeln(NOM);
{ affiche 'Schulze-Chmidt' }
Version 16/10/2006
Page 9/33
T1IF
2.4.5.
La fonction copy
Syntaxe: function copy(S:string; INDEX,COUNT:integer):string;

Cette fonction retourne comme valeur la sous-chane forme de COUNT caractres de la
chane S partir de la position INDEX. Cette extraction permet d'accder chacun des
caractres d'une chane.
Exemple:
NOM:='Muller';
S:=copy(NOM,2,3);
writeln(S);
{ affiche 'ull'}
Attention: Le rsultat de la fonction copy est du type string et non du type char. Pour
accder directement un sous-caractre d'une chane il faut appliquer la technique
explique dans le chapitre 2.2.
Exemple:
var C:char;
S:string;
...
S:='Yuppi!';
C:=S[3];
2.4.6.
{ met le troisime caractre de S dans C }
La procdure strtoint
Syntaxe: function strtoint(const S:string):integer;

Cette fonction lit une chane de caractres en entre et la transforme en une valeur
numrique qu'elle donne en sortie. Si S ne contient pas la reprsentation d'un entier, le
programme se termine avec une erreur du type ? is not a valid integer value ! ( ?
est remplacer par le nom de la variable correspondante.)
Exemples:
S:='25';
I:=strtoint(S);
writeln(I);
{ transforme '25' en 25 }
{ affiche 25 }
S:='25 ans';
I:=strtoint(S)
{ produit une erreur !!! }
Exemple plus complexe:

var ADRESSE:string;
NO:integer;
...
ADRESSE:='7, rue de la montagne';
NO:=strtoint( copy( ADRESSE,1, POS(',',ADRESSE)
Version 16/10/2006
-1
);
Page 10/33
T1IF
2.4.7.
La procdure inttostr
Syntaxe: function inttostr(VALUE:integer):string;

Rciproquement
la
procdure
VALUE en une chane de chiffres.
Exemple:
I:=35;
S:=inttostr(I);
writeln(S);
2.5.
inttostr
transforme
un
nombre
{ affiche '35' }
Compatibilit entre char et string
Exemple:
var S:string;
C:char;
...
S:='A';
C:='A';
Les deux variables reprsentent la mme lettre A, mais les deux variables ont une
reprsentation diffrente dans la mmoire!
Attention:
affectation valable:
S:=C;
affectation non valable:
C:=S;
par contre, ceci est une affectation valable:
C:=S[1];
Version 16/10/2006
Page 11/33
T1IF
3.
Tableau une dimension (Array)
Jusqu' prsent nous n'avons travaill qu'avec des variables de type simple, comme
integer, real, char, ..., ne contenant qu'une seule valeur un instant donn. Or, ceci
est insuffisant pour rsoudre certains problmes. Prenons l'exemple suivant:
En mathmatique la formule ci-dessous permet de calculer la somme de 10 valeurs qui
sont reprsentes par les variables A1, A2, ..., A10:
10
SOMME= Ai =A1 A2 A3 A4 A5 A6 A7 A8 A9A10

i=1
Essayons de programmer cette formule en Pascal:
Solution 1
var A1,A2,A3,A4,A5,A6,A7,A8,A9,A10:integer;
SOMME:integer;
...
SOMME:=A1+A2+A3+A4+A5+A6+A7+A8+A9+A10;
Que faut-il changer pour calculer la somme de 100 valeurs?
On voit bien que cette solution n'est pas applicable en pratique. C'est pour cela qu'on a
introduit le type de variable tableau (array).
3.1.
Dfinition
Une variable de type tableau (array) est une structure qui permet de regrouper un
certain nombre de valeurs d'un mme type de donnes, accessible par le mme nom.
Les diffrentes valeurs sont appeles lments du tableau.
Nous avons dj rencontr les array, inconsciemment (= sans le savoir), dans le
chapitre sur les textes. Voyons comment on dclare un tableau.
3.2.
Dclaration d'un tableau
Dclaration gnrale:
var NOM_TAB:array[DEBUT..FIN] of TYPE_DONNEE;
3.2.1.
Remarques
Les valeurs DEBUT et FIN sont les bornes du tableau. Ces valeurs doivent tre
connues avant la dclaration du tableau, p. ex.
const DEBUT = 1;
FIN
= 6;
var DE:array[DEBUT..FIN] of integer;
ou bien
var DE:array[1..6] of integer;
Version 16/10/2006
Page 12/33
T1IF
Les valeurs DEBUT et FIN doivent tre d'un type ordinal (integer, char, ... ) et
non pas real p. ex.
var ALPHABET:array['A'..'Z'] of integer;

CLASSE:array[1..22] of string[20];
Il faut que la borne infrieure soit toujours infrieure la borne suprieure, c'est
dire DEBUT FIN.
Les variables DEBUT et FIN peuvent avoir des valeurs ngatives, p. ex.
var T:array[-10..10] of real;

V:array[-12..-4] of char;
{T peut regrouper 21 nombres rels,
V peut regrouper 9 caractres}
Le type de donnes TYPE_DONNEE peut tre un type scalaire (integer, real,

char, string, boolean, ...). Tous les lments du tableau sont de ce type.
Attention:
La taille du tableau doit pouvoir tre dtermine lors de la dclaration.
Souvent il serait prfrable de fixer le nombre d'lments seulement lors de l'excution
du programme, ce qui mnerait la solution suivante,
qui n'est pas correcte:
var CLASSE:array[1..N] of string;

N:integer;
...
write('Entrer le nombre d''lves ');
read(N);
Il faut distinguer entre une dimension maximale, dfinie lors de la dclaration, et une
dimension effective qui dtermine le nombre d'lments stocker dans le tableau.
Optons plutt pour la solution suivante:
const NMAX = 30;

var CLASSE:array[1..NMAX] of string;
N:integer;
...
{maximum 30 lves/classe}
write('Entrer le nombre d''lves ');

read(N);
condition pour N:
N 30 !!!
Version 16/10/2006
Page 13/33
T1IF
3.3.
Accs aux lments d'un tableau
Le nom du tableau reprsente l'ensemble des valeurs du tableau. L'accs un lment

du tableau se fait par un indice qui reprsente la position de l'lment dans le tableau. La
syntaxe est la mme que pour accder aux diffrents caractres d'une chane de
caractres!
En gnral:
NOM_TAB[indice]
3.3.1.
Remarque
L'indice peut tre une constante, une variable ou bien une expression du mme type que
les bornes infrieure et suprieure.
Condition: DEBUT indice FIN
Exemple:
var B:array[1..5] of real;
Exemple de reprsentation du tableau B dans la mmoire
3.4 7.1 1.8 4.2 6.7
Le tableau B peut sauvegarder 5 valeurs du type real.
B[2]
: Le 2e lment du tableau = 7.
L'indice est une constante.
B[L]
: Le Le lment du tableau.
L'indice est une variable.
B[I+1] : Le (I+1)e lment du tableau.

L'indice est une expression.
3.4.
Remplir un tableau avec des valeurs
Il existe plusieurs manires pour remplir un tableau avec des valeurs (rappelons-nous
que lors de la dclaration seul l'espace ncessaire sauvegarder une variable sera
rserv, le contenu reste indtermin.)
3.4.1.
Affectation par :=
Exemples:
structogramme
Pascal
B[1]:=3;
{affectation avec une constante}
Version 16/10/2006
Page 14/33
T1IF
structogramme
Pascal
B[2]:=X;
{affectation avec une variable; X
doit tre du type TYPE_DONNEE (ou au
moins compatible avec ce type)}
B[3]:=B[1]-2;
{affectation avec une expression}
B[1]:=random(10);
{affectation
avec
un
alatoire = expression}
3.4.2.
nombre
Affectation par lecture
Exemple:
structogramme
Pascal
readln(B[5]);
Attention:
Si A et B sont 2 tableaux structures identiques, l'affectation suivante est possible:
A:=B;
Exemple:
var A,B:array[1..50] of char;
I:integer;
...
for I:=1 to 50 do readln(A[I]);
B:=A;
{ le tableau B aura les mmes lments que A,
c--d B[1]:=A[1];
B[2]:=A[2];
....
}
Version 16/10/2006
Page 15/33
T1IF
4.
Tableau plusieurs dimensions
Il est possible de reprsenter des tableaux o chaque lment est identifi par plusieurs
valeurs de ses indices. Il s'agit alors de tableaux plusieurs dimensions.
4.1.
Dclaration d'un tableau plusieurs dimensions
Dclaration gnrale:
var TAB:array[D1..F1,D2..F2,...,Dn..Fn] of TYPE_DONNEE;
Par la suite, on se limitera aux tableaux 2 dimensions.

Dclaration gnrale d'un tableau 2 dimensions, appel aussi matrice:
var TAB_DIM2:array[D1..F1,D2..F2] of TYPE_DONNEE;
Exemples:
var MATRICE:array[1..N,1..M] of real;
A:array[1..2,1..2] of integer;
on pourrait aussi dfinir A de la manire suivante:
var A:array[1..2] of array[1..2] of integer;
Remarques:
N reprsente le nombre de lignes, M reprsente le nombre de colonnes.
N peut tre diffrent de M.
Si N=M, alors on parle d'un tableau carr.
Mme dans un tableau plusieurs dimensions, tous les lments sont du mme
type de donne!
Soit la matrice A(2,2) =
1
0
5
3
Reprsentation dans la mmoire:
Version 16/10/2006
Page 16/33
T1IF
4.2.
Accs aux lments
Pour accder un lment du tableau 2 dimensions il faut indiquer deux indices

En gnral:
TAB_DIM2[indice1,indice2]
ou bien
TAB_DIM2[I,J]
Remarques:
indice1 ou I reprsente l'indice de la ligne
indice2 ou J reprsente l'indice de la colonne
Conditions:
D1 indice1 F1 et D2 indice2 F2
Exemple:
Pour attribuer les valeurs la matrice A(2,2)=
instructions suivantes:
A[1,1]:=
A[1,2]:=
A[2,1]:=
A[2,2]:=
1
0
5
3
, il faut programmer les
;
;
;
;
Version 16/10/2006
Page 17/33
T1IF
5.
Sous-Programmes
Les programmes dcrits jusqu' prsent comportaient un seul bloc, le programme

principal, faisant appel ventuellement des procdures et fonctions standard du
langage de Pascal. Pour rsoudre des problmes plus complexes, nous obtenons ainsi de
longues listes d'instructions, difficiles dominer. La plupart des langages de
programmation nous permettent de subdiviser nos programmes en sous-programmes,
plus simples et plus compacts. A l'aide de ces structures nous pouvons modulariser nos
programmes pour obtenir des solutions plus lgantes et plus efficaces.
Voici quelques avantages de la modularisation d'un programme en sous-programmes:
Elle permet de dcomposer un problme complexe en plusieurs problmes plus

simples rsoudre: mthode de programmation top-down.
Les sous-programmes peuvent tre crits et tests sparment.
Une fois test, un sous-programme peut tre rutilis plusieurs fois, soit dans le
mme programme, soit dans un autre programme, ce qui vite la duplication des
mmes squences d'instructions.
Le programme principal devient plus court et plus facile comprendre.
Un module peut tre chang ou remplac sans avoir besoin de toucher aux autres
modules du programme.
Un programme peut tre dvelopp en quipe par dlgation de la programmation

des modules diffrentes personnes ou groupes de personnes. Une fois
dvelopps, les modules peuvent constituer une base de travail commune.
Pascal distingue 2 types de sous-programmes: les procdures et les fonctions.
5.1.
Procdures
Une procdure est un sous-programme qui effectue une ou plusieurs oprations

prdfinies. Un certain nombre de procdures sont prdfinies par le langage de
programmation. En Pascal, l'utilisateur peut se servir des procdures comme randomize,
writeln, readln, ... en les appelant par leur nom. Outre ces procdures standards,
Pascal offre la possibilit de dfinir ses propres procdures.
5.1.1.
Dclaration d'une procdure
Une procdure doit tre dfinie dans la partie dclaration du programme appelant. Sa
structure ressemble fortement la structure d'un programme normal:
Elle commence par une entte: le mot cl procedure, suivi de son nom et de la
<liste des paramtres>, qui est optionnelle.
La <partie dclaration> peut comprendre la dfinition de constantes, la

dclaration de variables et mme la dfinition d'autres sous-programmes.
Entre begin et end; suit le <bloc d'instructions> qui sera excut chaque
appel de la procdure.
Version 16/10/2006
Page 18/33
T1IF
procedure PROC_NOM( <liste des paramtres> );

<partie dclaration>
begin
<bloc d'instructions>
end;
Exemple:
procedure PAUSE_ECRAN(pTEXT: string);
var C:char;
begin
write(pTEXT);
readln(C);
writeln;
end;
5.1.2.
Appel d'une procdure
L'appel d'une procdure constitue une instruction compose de son nom, suivi si
ncessaire de la liste des paramtres effectifs (actuels). La liste des paramtres actuels
doit tre mise entre parenthses.
PROC_NOM(<paramtres actuels>);
Par l'appel d'une procdure, le corps de la procdure est excut. La prochaine
instruction sera celle qui suit l'appel de la procdure.
Exemple:
PAUSE_ECRAN('Appuyez une touche pour continuer ...');
Attention:
Une procdure peut en appeler une autre. Mais une procdure qui est appele par une
autre procdure doit tre dfinie avant celle-ci.
5.1.3.
Structogramme
Pour chaque procdure que nous dfinissons, nous tablissons un structogramme spar
( modularit).
Le structogramme d'une procdure ressemble fortement celui d'un programme, avec la
diffrence que:
Le structogramme d'une procdure possde des coins 'arrondis'.
L'entte du structogramme ne contient pas seulement le nom de la procdure

mais aussi la liste des paramtres de la procdure.
Version 16/10/2006
Page 19/33
T1IF
Exemple:
Voici les structogrammes d'un programme qui attend que l'utilisateur appuie sur une
touche avant de s'arrter.
Code Pascal:
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
............................................................................................................................
Version 16/10/2006
Page 20/33
T1IF
5.2.
Fonctions
Une fonction peut effectuer une opration ou modifier le contenu de variables et retourne
TOUJOURS une valeur au (sous-) programme appelant. L'appel d'une fonction doit tre
intgr dans une expression (affectation, calcul, affichage).
Exemples:
La fonction FACTORIELLE (dfinie ci-dessous) retourne comme rsultat la

factorielle d'un nombre fourni comme paramtre.
Les fonctions prdfinies sqr, sqrt, random, ord, length, ...
5.2.1.
Dclaration d'une fonction
Une fonction le mme corps qu'un programme normal en Pascal avec la diffrence que
le bloc de la fonction commence avec le mot cl function et qu'elle retourne toujours
une valeur dont le type est indiqu la fin de l'entte. Il peut galement recevoir
plusieurs paramtres.
function NOM_FONC(<liste paramtres>): <type rsultat>;

<partie dclaration>
begin
<bloc d'instructions>
NOM_FONC:=<rsultat>
end;
Exemple:
function FACTORIELLE(pN:integer): double;
var I:integer;
RES:double;
begin
RES:=1;
for I:=2 to pN do RES:=RES*I;
FACTORIELLE:=RES;
end;
Remarques:
<type rsultat> reprsente le type de la valeur retourne par la fonction.
Aprs la fin de l'excution de la fonction, la valeur retourner comme rsultat doit

tre affecte au nom de la fonction.
Version 16/10/2006
Page 21/33
T1IF
5.2.2.
Appel d'une fonction
L'appel d'une fonction s'effectue toujours dans le contexte d'une valuation d'une
expression, vu que chaque fonction retourne une valeur.
Exemples:
L'appel la fonction FACTORIELLE peut tre intgr:
dans une affectation:
F:=FACTORIELLE(N);
dans un calcul:
A:=1/FACTORIELLE(B);
dans une comparaison:
if (FACTORIELLE(NR)>1000000) then
writeln('Trop de cas analyser!');
dans une instruction d'affichage:
writeln('La factorielle de ', X ,' vaut ', FACTORIELLE(X));
5.2.3.
Structogramme
Pour chaque fonction que nous dfinissons, nous tablissons un structogramme part.
Le structogramme d'une fonction ressemble fortement celui d'un programme:
Le structogramme d'une fonction possde est pourvu de coins 'arrondis'.
Dans l'entte du structogramme nous utilisons la mme syntaxe de dclaration

qu'en Pascal, mais sans indiquer le mot cl 'function'.
A l'intrieur du structogramme, le nom de la fonction symbolise la valeur qui est

retourne comme rsultat. Ainsi, la plupart des structogrammes se terminent par
une affectation de la forme:
<nom_fonction>
<expression>
Dans le (sous-) programme appelant, l'appel de la fonction est intgr dans une
expression.
Version 16/10/2006
Page 22/33
T1IF
Exemple:
Voici le code source d'un programme qui calcule la factorielle d'un nombre en utilisant
une fonction dfinie par le programmeur:
program FUNC_TEST;
var X:integer;
{ dfinition de la fonction }
function FACTORIELLE(pN:integer): double;
var I:integer;
RES:double;
begin
RES:=1;
FACTORIELLE:=RES;
end;
{ programme principal }
begin
write('Entrez un nombre entier positif: ');
readln(X);
writeln('La factorielle de ', X, ' vaut ', FACTORIELLE(X));
readln;
end.
Structogrammes:
Version 16/10/2006
Page 23/33
T1IF
5.3.
La notion de porte de variable
Les constantes et variables utilises par des sous-programmes peuvent tre dclares ou
bien dans la partie dclaration du programme principal ou bien dans la partie dclaration
du sous-programme.
5.3.1.
Variables ou constantes locales
Les variables ou constantes dclares dans un sous-programme sont connues

uniquement dans ce sous-programme. Ce sont des variables ou constantes locales ce
sous-programme. Un emploi par le programme principal ou un autre sous-programme
entrane une erreur lors de la compilation.
Dans l'exemple FUNC_TEST, les variables RES et I sont des variables locales la fonction
FACTORIELLE. Ainsi, aucun autre programme ou sous-programme n'a accs ces
variables.
5.3.2.
Variables ou constantes globales
Les variables ou constantes dclares dans le programme principal sont connues dans
tout le programme et peuvent tre utilises par le programme principal et tous ses sousprogrammes. On dit que ce sont des variables ou constantes globales.
Dans l'exemple ci-dessous, les variables RES et I sont dclares globalement dans le
programme principal. Ainsi, le programme et tous ses sous-programmes ont accs ces
variables.
program FUNC_TEST2;
var I: integer;
RES:longint;
X:integer;
{ dclarations globales }
function FACTORIELLE(pN:integer): longint;

{ dfinition de la fonction }
begin
RES:=1;
FACTORIELLE:=RES;
end;
begin { programme principal }
write('Entrez un nombre entier positif: ');
readln(X);
writeln('La factorielle de ', X, ' vaut ', FACTORIELLE(X))
end.
UTILISATION DE DECLARATIONS GLOBALES
Les constantes et variables globales sont utiliser avec beaucoup de prcaution,
puisqu'elles crent des liens invisibles entre les programmes et les sous-programmes. La
modularit d'un programme en souffre et le programmeur risque de perdre la vue
d'ensemble.
Ainsi il est toujours prfrable d'viter les dclarations globales et de dclarer
les variables aussi 'localement' que possible dans le sous-programme o elles
sont utilises.
Version 16/10/2006
Page 24/33
T1IF
Exemples:
Voir programme FUNC_TEST:

Toutes les variables utilises dans la fonction FACTORIELLE sont dclares localement (ou
lui parviennent comme paramtres). Ainsi la fonction FACTORIELLE est un module
indpendant qui peut facilement tre copi et utilis dans n'importe quel autre
programme.
Voir programme FUNC_TEST2:

Comme les variables RES et I sont dclares globalement dans le programme principal,
la fonction FACTORIELLE n'est plus un module indpendant. Avant de pouvoir utiliser
cette fonction dans un autre programme, nous devons rechercher et copier
minutieusement toutes les dclarations de variables globales utilises dans la procdure.
UTILISATION DE VARIABLES DU MME NOM
Si une variable locale a le mme nom qu'une variable globale, le sous-programme se
rfre la dclaration locale de la variable. On peut dire que la variable locale cache les
variables globales du mme nom. Il est vident que cette situation est viter si
possible.
Exemple:
program AFFICHAGE;
const A=6;
var B,C:integer;
procedure PROC1;
var A,C:integer;
begin
A:=8;
B:=B*3;
C:=0;
writeln(A:4, B:4, C:4)
end;
begin
B:=3;
C:=10;
writeln(A:4, B:4, C:4);
PROC1;
writeln(A:4, B:4, C:4)
end.
Qu'est-ce qui sera affich l'cran?
....................................
....................................
....................................
Version 16/10/2006
Page 25/33
T1IF
5.4.
Sous-programmes avec paramtres
En gnral:
Dans la dfinition d'un sous-programme, la liste des paramtres est une liste de
paramtres formels, dont le type doit tre dfini. Chaque paramtre est indiqu
par un identificateur suivi d'un double point et de son type de donne. Les
dfinitions de paramtres de diffrents types sont spares par un point-virgule.
Lors de l'appel du sous-programme, qui est opr en invoquant le nom du sousprogramme, la liste des paramtres est remplace par un nombre gal de
paramtres effectifs (actuels), correspondant l'ordre et au type des paramtres
formels. L'excution des instructions du sous-programme se fait avec les valeurs
actuelles.
Exemple:
program CALCUL;
var A,B,SOMME,PRODUIT:integer;
{dfinition de la procdure AFFICHER avec 4 paramtres formels }
procedure AFFICHER(pOPERATION:char; pT1,pT2,pRESULTAT:integer);
begin
writeln(pT1, pOPERATION, pT2, ' = ', pRESULTAT)
end;
begin
...
SOMME:=A+B;
AFFICHER('+', A, B, SOMME);
{ 1. appel avec paramtres actuels }
PRODUIT:=A*B;
AFFICHER('*', A, B, PRODUIT);
{ 2. appel avec paramtres actuels }
...
end.
Les paramtres formels peuvent tre d'un des types de donne connus: integer, real,
..., string, char.
Version 16/10/2006
Page 26/33
T1IF
5.5.
Transmission des paramtres

(Parameterbergabe)
Il existe 2 modes de transmission de paramtres:

1. Paramtres transmis par valeur (call-by-value, Wertbergabe)
Lors de la transmission par valeur, la valeur du paramtre actuel est passe au
sous-programme. Le paramtre formel du sous-programme est considrer dans
ce cas comme une variable locale qui est initialise automatiquement par la valeur
indique lors de l'appel. A l'intrieur du sous-programme, nous pouvons donc
changer les valeurs de ces paramtres sans influencer les valeurs originales dans
les fonctions appelantes.
Les modifications qui se font sur un paramtre pass par valeur n'auront
pas d'influence sur la valeur du paramtre actuel dans le programme
appelant.
2. Paramtres transmis par rfrence (call-by-reference, Variablenbergabe)
Lors de la transmission par rfrence, l'adresse du paramtre actuel est transmis
au sous-programme. Des modifications excutes par le sous-programme se
droulent sur l'adresse du paramtre actuel ce qui implique qu'aprs l'excution
de la procdure ces modifications restent valables pour le programme appelant.
Dans la liste des paramtres, les paramtres transmis par rfrence sont marqus
par le mot cl var.
Les modifications qui se font sur un paramtre pass par rfrence
s'appliquent en mme temps au paramtre actuel dans le programme
appelant.
Version 16/10/2006
Page 27/33
T1IF
Exemple 1: Transmission des paramtres par valeur

Structogrammes:
Programme en Pascal:
program PERM_VALEUR;
var A,B:integer;
procedure PERMUTATION(pA,pB:integer);
{2 paramtres transmis par valeur}
var TMP:integer;
begin
TMP:=pA;
pA:=pB;
pB:= TMP
end;
begin
A:=3;
B:=5;
writeln(A:4, B:4);
PERMUTATION(A,B);
writeln(A:4, B:4)
end.
....................................
....................................
Justifiez votre rponse en donnant des explications!
............................................................................................................................
............................................................................................................................
Exemple 2: Transmission des paramtres par rfrence

Structogrammes:
Version 16/10/2006
Page 28/33
T1IF
Programme en Pascal:
program PERM_REFERENCE;
var A,B:integer;
procedure PERMUTATION(var pA,pB:integer);
{2 par. transmis par rfrence}
var TMP:integer;
begin
TMP:=pA;
pA:=pB;
pB:=TMP
end;
begin
A:=3;
B:=5;
writeln(A:4, B:4);
PERMUTATION(A,B);
writeln(A:4, B:4)
end.
....................................
....................................
Justifiez votre rponse en donnant des explications!
............................................................................................................................
............................................................................................................................
6.
Enregistrements
Chaque variable utilise jusqu' prsent ne reprsentait chaque instant qu'un seul type
Version 16/10/2006
Page 29/33
T1IF
de variable (p.ex. integer, real, char, ). Une extension cette dfinition vous a t
montre par le biais des tableaux une ou plusieurs dimensions. Chaque lment d'un
tableau tait du mme type.
Or, il est souvent utile de rassembler des lments sous un mme nom et de les traiter
comme unit. Pensez p.ex. l'adresse d'une personne. Si vous voulez lui adresser une
lettre, vous devez indiquer toutes les donnes sur l'enveloppe :
Prnom Nom
Uwe Schlapp
N, rue
77 Brunnenweg
CP et Localit
9989 Glcksburg
Un autre exemple serait un article dans un magasin, une rservation d'un voyage, Ce
que l'on remarque dans tous ces exemples, c'est que les diffrentes proprits sont
souvent de types diffrents. Pour l'exemple de l'article, on pourrait utiliser les types
suivants:
Numro de l'article
: integer
Nom de l'article
: string
Prix net
: real
Livreur
: string
Comme indiqu, nous ne connaissons jusqu'ici aucune structure, qui nous permet de
sauvegarder diffrents types et de les regrouper sous un seul nom (p.ex. article). Pascal
nous offre toutefois une possibilit de sauvegarder diffrents lments et de les
regrouper sous un enregistrement (record).
6.1.
6.1.1.
Dclaration d'un enregistrement

Dclaration d'une variable
var NOM_REC: record

identificateur_1:TYPE_DONNEE_1;
identificateur_2:TYPE_DONNEE_2;
...
end;
identificateur_n:TYPE_DONNEE_n;
identificateur_x indique le nom du champ; TYPE_DONNEE reprsente le type du

champ; il s'agit de n'importe quel type de donne dfini.
Version 16/10/2006
Page 30/33
T1IF
Exemples:
var PERSONNE:record
NOM,PRENOM:string;
AGE
:integer;
end;
var HORAIRE:record
HEURE :0..23;
MINUTE :0..59;
SECONDE:0..59;
end;
6.1.2.
Dclaration d'un nouveau type
Exemples:
type TMATRICE = array [1..2,1..2] of integer;
THORAIRE = record
HEURE
: 0..23;
MINUTE : 0..59;
SECONDE : 0..59;
end;
var A:TMATRICE;
DEBUT,FIN:THORAIRE;
6.2.
Utilisation d'un enregistrement
En gnral:
NOM_REC.identificateur
Exemples:
DEBUT.HEURE:=8;
DEBUT.MINUTE:=10;
DEBUT.SECONDE:=0;
write(FIN.MINUTE);
{ ou bien }
with DEBUT do
begin
HEURE:=8;
MINUTE:=10;
SECONDE:=0;
end;
Version 16/10/2006
Page 31/33
T1IF
6.2.1.
Imbrications d'enregistrements
La composante d'un enregistrement peut de nouveau tre un enregistrement.
Exemple:
type TPERS_INFO = record
NOM:string;
DATE_NAISS:record
JOUR :1..31;
MOIS :1..12;
ANNEE:1900..2000;
end;
LOCALITE:string[30];
end;
var PERSONNE:TPERS_INFO;
...
begin
PERSONNE.NOM:='MULLER PITTI';
PERSONNE.DATE_NAISS.JOUR:=7;
PERSONNE.DATE_NAISS.MOIS:=3;
PERSONNE.DATE_NAISS.ANNEE:=1985;
{ ou bien }
with PERSONNE do
begin
PERSONNE.NOM:='MULLER PITTI';
With DATE_NAISS do
begin
JOUR:=7;
MOIS:=3;
ANNEE:=1985;
end;
end;
6.2.2.
Tableau d'enregistrements
Exemple:
var PERS_LISTE:array [1..100] of TPERS_INFO;
...
begin
PERS_LISTE[4].NOM:=MULLER';
write(PERS_LISTE[33].DATE_NAISS.ANNEE);
...
Version 16/10/2006
Page 32/33
T1IF
Source:
Ce document est essentiellement bas sur le cours de programmation rdig par Simone
Beissel (2003) et Fabrice Roth (2004) pour les classes de T1IF.
Autres sources d'inspiration:
Initiation la programmation, Simone Beissel, T0IF, 2003

Programmation en Delphi, Frdric Faber, 12GE/T2IF, 1999
Les gnrations Pascal, Serge Linckels, 11TG/12GE, 2004
Help of Delphi 6, Borland, 2001
Version 16/10/2006
Page 33/33

COURS Programmation

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

COURS Programmation

Transféré par

Droits d'auteur :

Formats disponibles

T1IF

BEISI'03 => ROTFA'05 => FISRO'06

BEISI'03 => ROTFA'05 => FISRO'06

Table des matires

1.3. Fonctions associes au type char...................................................................5

2. Les chanes de caractres (textes)........................................................................6

2.4. Procdures et fonctions associes au type string..............................................9

2.5. Compatibilit entre char et string.................................................................11

3.3. Accs aux lments d'un tableau..................................................................14

3.4. Remplir un tableau avec des valeurs.............................................................14

4. Tableau plusieurs dimensions...........................................................................16

5.3. La notion de porte de variable....................................................................24

5.4. Sous-programmes avec paramtres..............................................................26

6.2. Utilisation d'un enregistrement....................................................................31

BEISI'03 => ROTFA'05 => FISRO'06

Dclaration d'une variable

Oprations dfinies sur le type char

Les oprateurs de comparaison =, <, <=, >=, >, <>

'?' < 'A'

BEISI'03 => ROTFA'05 => FISRO'06

BEISI'03 => ROTFA'05 => FISRO'06

Fonctions associes au type char

Syntaxe: function chr(B:byte):char;

{ l'cran la lettre 'A' est affiche }

Syntaxe: function ord(C:char):byte;

{ l'cran la valeur 65 est affiche }

Syntaxe: function upcase(C:char):char;

BEISI'03 => ROTFA'05 => FISRO'06

Les chanes de caractres (textes)

Dclaration d'une variable ou constante

{ dclaration avec taille dynamique }

Reprsentation d'une variable du type string

Supposons qu'on excute ensuite l'instruction:

Alors la reprsentation change de la manire suivante:

L'instruction writeln(MOT[2]); affiche la lettre 'a' l'cran.

BEISI'03 => ROTFA'05 => FISRO'06

BEISI'03 => ROTFA'05 => FISRO'06

Oprations dfinies sur le type string

Les oprateurs de comparaison =, <, <=, >=, >, <>

Les oprateurs de comparaison se portent sur la longueur de la chane de caractres. Si

L'oprateur + pour concatner 2 chanes.

BEISI'03 => ROTFA'05 => FISRO'06

Procdures et fonctions associes au type string

En Pascal il existent plusieurs procdures et fonctions qui permettent de manipuler des

Syntaxe: function length(S:string):integer;

Syntaxe: function pos(SUBST:string; S:string):integer;

Syntaxe: procedure delete(var S:string; INDEX,COUNT:integer);

Syntaxe: procedure insert(SOURCE:string; var S:string; INDEX:integer);

BEISI'03 => ROTFA'05 => FISRO'06

Syntaxe: function copy(S:string; INDEX,COUNT:integer):string;

{ met le troisime caractre de S dans C }

Syntaxe: function strtoint(const S:string):integer;

{ produit une erreur !!! }

Exemple plus complexe:

BEISI'03 => ROTFA'05 => FISRO'06

Syntaxe: function inttostr(VALUE:integer):string;

Compatibilit entre char et string

affectation non valable:

par contre, ceci est une affectation valable:

BEISI'03 => ROTFA'05 => FISRO'06

Tableau une dimension (Array)

SOMME= Ai =A1 A2 A3 A4 A5 A6 A7 A8 A9A10

Essayons de programmer cette formule en Pascal:

Dclaration d'un tableau