I.
D'histoire Pascal
Ce langage a été créé en 1969 à l'école polytechnique de ZURICH par N. WIRTH. Il a été
conçu pour permettre d'enseigner la programmation comme une science. Ce langage est à la
base d'une nouvelle méthode de programmation : la programmation structurée, et c'est pour
cette raison que ce langage a eu un tel succès dans l'enseignement. Il s'agit d'un langage de
3ème génération.
En 1975, PASCAL a très largement pénétré le monde de la recherche et des universités. Pour
son développement, PASCAL devait être accepté dans le monde industriel, ce qui a été plus
ou moins bien réussi grâce à :
De bonnes relations entre les universités et les industries (aux USA !)
Les caractéristiques propres à PASCAL (simplicité, fiabilité)
L'effort du département de la défense américaine) Dès 1975, il y a création d'un groupe de
travail (High Order Language Working Group) chargé de déterminer les caractéristiques
d'un langage de haut niveau bien adapté au développement de ses applications militaires et
permettant d'apporter des réponses à la crise du logiciel. L'étude a montré qu'un nouveau
langage devait être créé à partir du PASCAL.
A l'époque, c'est-à-dire la préhistoire, Pascal a été adopté par de nombreux constructeurs
comme langage de développement (CRAY Computer, ICL, Texas Instruments...), et surtout,
le compilateur PASCAL a été rapidement disponible sur les micro-ordinateurs.
II. Pascal
Le langage C est un des langages les plus utilisés actuellement. Cela est dû au fait que
le langage C est un langage comportant des instructions et des structures de haut niveau
Remarque : contrairement à l'assembleur par exemple tout en générant un code très rapide
grâce à un compilateur très performant.
Cela est dû en réalité au fait que les instructions du langage sont faites de telle façon à être
assez proches du langage machine, ce qui se traduit par un programme compact (donc rapide)
dans la mesure où le programmeur respecte une syntaxe proche des spécifications. Ainsi, les
programmes en C sont très peu long. La contrepartie est bien évidemment que le langage C
reste un langage assez compliqué. Toutefois, son apprentissage est désormais nécessaire pour
quiconque s'intéresse à la programmation, et cet apprentissage vaut le coup !"
Pareil pour le Pascal, mais en un peu moins. Le Pascal est un langage de développement le plus
utilisé pour l'enseignement, et un des plus utilisé en programmation professionnelle sur micro-
ordinateur. D'une manière générale, il se raconte que le PASCAL est le langage des "amateurs"
et le C celui des professionnels. Cela énerve beaucoup la multitude de très bons programmeurs
en PASCAL, et valorise les développeurs C (qui peuvent d'ailleurs être tout aussi bons !). La
grande famille des PASCALIENS est extrêmement vivante, à travers des forums et des listes
de diffusion.
Le Pascal permet de manipuler tout type de variable au même titre que le C, sauf en ce
qui concerne les accès directs à la mémoire (pointeurs) pour lesquels il est un peu fastidieux.
Malgré tout, il est possible de programmer en Pascal tout ce qu'il est possible de faire en C.
Le Pascal impose une structure de programme cohérente, avec la définition
systématique des variables et des types, ce qui permet d'avoir un contrôle maximum à
l'exécution. Le fait que le recours aux pointeurs ne soit pas sa tasse de thé oblige à faire dès le
départ une bonne analyse, en forçant le programmeur à respecter sa philosophie et à garder une
bonne transposition algorithme/programme. Le code est relativement compact mais permet une
très bonne lisibilité, donc une maintenance aisée (en théorie...).
Enfin, la structuration permet de découper le programme en unités de travail, chacune
ayant ses propres variables et types. La conception descendante de la structure du programme
permet ce découpage et augmente la logique de la structure et la lisibilité. Il y a beaucoup moins
de possibilités d'écrire un programme en Pascal qu'un programme en C, car l'utilisation à
outrance des astuces de programmation (rendant le code illisible) est limitée.
La rapidité d'exécution d'un programme écrit en Pascal est très bonne, à peine moins élevée que
celle d'un (bon) programme écrit en C, et la taille des exécutables est relativement compacte,
bien que cet aspect soit de plus en plus anodin au regard des applications Windows où la taille
du programme est conditionnée par les "ressources", c'est-à-dire les images et autres icônes.
III. Histoire du Turbo Pascal
L'essor du Pascal a suivi celle de la micro-informatique, grâce notamment à Philippe Khan,
Français bien connu qui a le premier commercialisé un compilateur performant et fiable : Turbo
Pascal. Il a fondé la société BORLAND et est actuellement le PDG (CEO) de la société
STARFISH.
Turbo Pascal proposait un environnement complet (pour l'époque) de programmation
avec éditeur de texte performant, compilateur, aide et tout et tout. Avec les produits concurrents,
il fallait écrire le code dans un éditeur de texte séparé (vu le niveau de ces éditeurs à l'époque...),
puis sortir et lancer le compilateur en ligne de commande (du style "tpc -f -i -o monprog.pas
monprog.exe"), puis lancer le programme pour le tester. Dans Turbo Pascal, une seule touche
suffisait pour faire tout ça. Depuis, BORLAND en faisant vivre son Turbo Pascal n'a cessé
d'apporter des améliorations intelligentes au langage, qui du coup n'était plus au standard de M.
WIRTH. Mais puisqu'il avait un quasi-monopole, cela lui fut plus facile que pour le langage C,
pour lequel un comité de normalisation doit se rassembler pour chaque évolution, avec de
coûteuses bagarres à la clé. Le PASCAL (en tout cas le Turbo Pascal) a pu ainsi évoluer en
gardant son esprit et sa philosophie.
Vinrent ensuite les versions de plus en plus perfectionnées, jusqu'à la 6 qui dispose d'un
environnement à fenêtre (sous DOS of course), d'une programmation Objet et d'une
bibliothèque nommée Turbo Vision, sorte de Windows-Like en mode texte, qui permet de
développer des applications supportant la souris, les boutons, la touche Tab (beurk !), les
raccourcis clavier, etc.
La version 7 est déclinée en deux versions : une pour DOS et une pour Windows avec
l'apparition d'OWL (Object Windows Library), un genre de Turbo Vision pour Windows, qui
permettait déjà d'encapsuler, c'est-à-dire de cacher la complexité des API de Windows, mais ça
n'était pas encore ça, d'autant plus qu'un petit concurrent sortit alors : Microsoft Visual Basic
(VB) et sa programmation "visuelle". La réponse de BORLAND fut quasi instantanée, et une
bande de programmeurs géniaux inventa "Delphi" en 1995, environnement hérité de Turbo
Pascal. Delphi marqua immédiatement des points grâce à un compilateur performant générant
du vrai code machine (contrairement à VB qui était un interpréteur ou un pseudo-compilateur),
un environnement "bidirectionnel" (l'ajout d'un objet sur une fenêtre par glisser/déposer
provoque l'écriture automatique de code et inversement), une très bonne transition avec le Turbo
Pascal Objet, et la fameuse VCL (Visual Component Library) dont les sources sont livrées et
qui sont une mine d'information et de formation aux programmeurs de tout poil.
IV. De la structure du langage et des principaux mots-clés
Tout d'abord, nous sommes d'accord : notre but est d'écrire un programme ; quand notre
programme sera suffisamment élaboré, on pourra appeler ça une application (ça fait pro). Tous
nos programmes seront constitués de la même manière, dont voici un exemple :
Program MonProg;
begin
end.
Il faut savoir que le code source d'un programme Pascal, c'est un fichier texte, que l'on pourrait
tout à fait écrire avec le bloc-notes de Windows. Autrement dit, il s'agit d'un texte sans aucune
mise en forme (pas de gras, italique...). Donc pour s'y retrouver un peu, on met des majuscules,
mais c'est uniquement pour faciliter la lecture. Évidemment, ce programme ne fait rien, mais il
se compilera et s'exécutera quand même. Program, begin et end sont des mots-clés. Il existe
comme cela de nombreux mot-clés, qui ne peuvent être utilisés à d'autre fin que celle définie
par le compilateur. MonProg est le nom que j'ai donné au programme (noter le point-virgule
après MonProg, et le point après end). Si on complique, on pourrait avoir :
Program MonProg;
var
i : integer;
begin
i:=1;
end.
Dans cet exemple, on a commencé à ajouter des traitements à faire, sous forme d'instructions.
On utilise une variable, qui s'appelle i, et dans laquelle on met la valeur 1. Cela se traduit par
l'instruction "i:=1". Cette variable doit obligatoirement être déclarée en début de programme,
grâce à la clause VAR. En fait dans cette clause, on stocke toutes les déclarations de toutes les
variables. Par exemple :
Program MonProg;
var
i : integer;
j : string;
begin
i:=1;
j:='Bonjour à tous';
end.
Notez les points-virgules en fin de chaque instruction. Pour rendre le texte plus lisible, on
indente le texte, de manière à ce que chaque bloc soit décalé vers la droite. Deux espaces
suffisent pour dégager ce que contient la clause VAR et ce qu'il y a entre le begin et end. Cette
présentation est extrêmement importante : utilisez-la au fur et à mesure que vous tapez le texte,
et non après avoir tout tapé.
Texte non indenté, à NE PAS FAIRE :
Program MonProg;
var
i : integer;
j : string;
begin
i:=1;
j:='Bonjour à tous';
end.
Allez, puisqu'on est bien avancé, je vous présente d'un coup d'un seul la structure complète d'un
programme :
Program <nom du prog>;
uses MonUnit1, MonUnit2, ...;
const
maconstante1 = <valeur>;
...
type
montype1 : <type de donnée>;
montype2 : <type de donnée>;
...
var
mavar1 : <type de donnée>;
mavar2 : <type de donnée>;
...
procedure MaProc1;
begin
<instructions>;
...
end;
function MaFonct1;
begin
<instructions>;
...
end;
begin
<instructions>;
maproc1;
mavar1:=MaFonct1;
...
end.
La première partie (Program, Var), vous connaissez presque. On a simplement ajouté deux
choses :
Uses : Indique qu'on utilise des fonctions et outils contenus dans d'autres fichiers de
programme (nommés des unités) que celui dans lequel on travaille.
Types : Cette clause sert à définir des types de données particulières.
Procédure et fonction : On verra plus tard. L'essentiel est de savoir que ces procédures et
fonctions sont situées AVANT le bloc principal begin/end.
En attendant, essayez ça :
Program MonPremierProg;
var
s : string;
begin
s := 'Salut à tous !';
writeln(s);
readln;
end.
En Turbo Pascal, taper le texte et lancer la compilation (F9).
En Delphi 4, nous avons un problème, car cet environnement est prévu pour générer des
applications graphiques, et le modèle d'application console n'est pas disponible en Delphi 4 :
Fichier/Tout fermer
Fichier/Nouveau
Dans l'onglet application, choisir "texte", et taper le texte du programme
Une fois le texte tapé, Fichier/Enregistrer, choisir un répertoire sur votre disque et taper
"crt1.dpr". Ensuite cliquer sur le bouton Enregistrer
Aller à nouveau dans Fichier/Tout Fermer
Aller dans Fichier/Réouvrir et choisir "crt1.dpr"
Pour compiler et lancer le programme, choisir Exécuter/Exécuter (ou F9). Pour fermer
l'application, appuyer sur la touche Entrée.
Notre algorithme est le suivant :
1. Affecter une valeur à une variable nommée S s:='Salut à tous';
2. Ecrire le contenu de la variable à l'écran Writeln(s);
3. Lire une touche au clavier Readln;
V. Procédures et fonctions
Lorsque notre programme s'étoffe un peu, il est hors de question de le décrire séquentiellement,
même en indentant, vous imaginez 20000 lignes d'un seul bloc ! D'autre part, il peut être
intéressant de définir des sous-programmes exécutant certaines tâches pour pouvoir les
réutiliser. C'est précisément ce à quoi servent les procédures et les fonctions. D'ailleurs, vous
en avez déjà utilisé dans l'exemple ci-dessus : writeln et readln sont des procédures définies "en
standard".
Imaginons, dans notre exemple précédent, que nous demandions à l'utilisateur de notre
programme de saisir des mots, et qu'il nous faille en faire une phrase en les concaténant. On
pourrait faire :
Program MonDeuxiemeProg;
var
s, Phrase : string;
begin
writeln('Entrez un mot :');
readln(s);
Phrase:=s;
writeln('Entrez un deuxième mot :');
readln(s);
Phrase:=Phrase+s
writeln('Entrez un troisième mot :');
readln(s);
Phrase:=Phrase+s;
writeln('La phrase complète est :');
writeln(Phrase);
end.
J'écris un texte à l'écran (remarquez les "quotes" entourant les chaînes de caractères) pour
dire à l'utilisateur ce qu'il doit faire
Je lis ce qu'il tape
Je mets le résultat dans ma variable phrase
Je lui demande de saisir un autre mot, et je lis ce qu'il tape
Je cumule le contenu de phrase avec ce qu'il a tapé dans s (phrase: =phrase+s)
Enfin, j'affiche la phrase complète.
En dehors du fait que c'est un peu répétitif, si je veux insérer une virgule après chaque mot
tapé, je devrai le faire trois fois. Nous allons donc définir une fonction qui va faire tout ça une
fois pour toute :
Program MonDeuxiemeProg;
function ConstruitPhrase(phrase:string):string;
var s : string;
begin
readln(s);
ConstruitPhrase:=phrase+', '+s;
end;
var
Phrase : string;
begin
Phrase:=''; {initialiser à chaîne vide}
{premier mot}
writeln('Entrez un mot :');
Phrase:=ConstruitPhrase(Phrase);
{deuxième mot}
writeln('Entrez un deuxième mot :');
Phrase:=ConstruitPhrase(Phrase);
{troisième mot}
writeln('Entrez un troisième mot :');
Phrase:=ConstruitPhrase(Phrase);
{résultat}
writeln('La phrase complète est :');
writeln(Phrase);
end.
Les Remarques
Les commentaires entre accolades. Ce texte est ignoré du compilateur.
Aussi l'initialisation de la variable phrase.
Ceci est extrêmement important, car lorsqu'un programme démarre, les variables sont
dans un état "indéfini" et peuvent contenir n'importe quoi. Ainsi la première fois qu'on
appelle notre fonction, il faut bien qu'on lui envoie une chaîne vide (réflechissez voyons !!).
La déclaration a été descendue juste au-dessus du begin de début, pour lever toute
ambiguïté.
En effet, les variables, fonctions et procédures ne sont visibles que si elles sont situées au-
dessus du code qui les appelle.
V.1. Déclaration de fonction
J'ai donc créé la fonction suivante :
function ConstruitPhrase(phrase:string):string;
var s : string;
begin
readln(s);
ConstruitPhrase:=phrase+', '+s;
end;
Construit Phrase est le nom.
Vient ensuite le paramètre (phrase:string) qui permet "d'envoyer" une donnée à la fonction.
Celle-ci est de type chaîne de caractères.
Ensuite, après les deux points, j'indique que ma fonction doit me retourner une chaîne de
caractères.
Cette fonction prend donc ce que je lui donne (Phrase), ajoute une virgule, puis ce que vient
de taper l'utilisateur. On indique que c'est ce résultat qui doit être renvoyé en le stockant dans
une "variable" qui est le nom de la fonction : ConstruitPhrase:=phrase+', '+s;.
On aurait pu aussi, en Delphi, utiliser le mot Result au lieu du nom de la fonction :
result:=phrase+', '+s;.
V.2. Utilisation de fonctions
Pour utiliser la fonction, il suffit de citer son nom en lui indiquant le paramètre qu'elle demande :
ConstruitPhrase(Phrase,s);
Sauf que puisque c'est une fonction, je dois récupérer le résultat, que je stocke dans ma
variable phrase :
Phrase:=ConstruitPhrase(Phrase);
En clair, j'appelle la fonction en lui donnant ce que contient Phrase, et elle me renvoie Phrase
augmenté d'une virgule et d'un mot tapé par l'utilisateur. Remarquez que la variable s n'est plus
déclarée en haut du programme, mais localement à la fonction, car je ne m'en sers que dans
cette fonction. On ne peut pas l'utiliser en dehors. Une procédure est très similaire, sauf qu'elle
ne renvoie rien. On aurait pu s'en sortir quand même, car il est possible de faire en sorte que le
paramètre que l'on passe puisse nous revenir modifié : il s'agit d'un passage de paramètre par
adresse. La syntaxe serait la suivante :
[...]
procedure ConstruitPhrase(var phrase:string);
var s : string;
begin
readln(s);
phrase:=phrase+', '+s;
end;
begin
Phrase:=''; {initialiser à chaîne vide}
{premier mot}
writeln('Entrez un mot :');
ConstruitPhrase(Phrase);
[...]
end.
Dans ce cas, je passe Phrase en paramètre, la procédure travaille dessus, la modifie, et le résultat
m'est renvoyé. Cela est possible grâce au mot-clé var indiqué avant le paramètre. En fait, la
procédure travaille sur la même variable (même si le nom aurait pu être différent) que celle du
programme principal.
V.3. De l'Algorithme ou de l'art de ne pas être trop astucieux
Toute suite Définition du Petit Larousse : Suite finie d'opérations élémentaires constituant un
schéma de calcul ou de résolution d'un problème.
Ce mot est à connaître et à placer régulièrement dans les conversations !
Plus banalement, on appelle Algorithme d'opérations, décrites par un programme ou
tout bonnement griffonnées sur une feuille de papier, dont le but est de résoudre un problème.
On peut dire qu'il s'agit de la description logique d'un programme.
On rattache à l'algorithmie (et pas algorythmie : on n'est pas dans un orchestre !) tous
les schémas que vous avez pu voir un jour ou l'autre, et qui portent le nom d'organigramme ou
d'ordinogramme. En voici un exemple :
Si vous avez un rapport argumenté à produire, vous pouvez vous amuser à faire ce genre
de schéma, sinon une feuille de papier et un crayon suffiront.
Le but de notre algorithme est de bien mettre à plat toutes les étapes nécessaires à la résolution
d'un problème. Il n'a en lui-même pas forcément de concrétisation matérielle : on parle
d'algorithme, mais on ne l'écrit pas forcément ! Tout ça pour dire qu'un programme bien écrit
et bien commenté se suffit à lui-même pour être compréhensible.
Attrapez votre souris, regardez brièvement l'exemple un peu plus bas et revenez ici. C'est bon
?
Dans cet exemple, le problème posé est d'écrire une fonction qui doit chercher dans une liste
un objet à partir de son nom, et nous retourner un pointeur vers cet objet. La routine doit
accepter un paramètre pour soit ne rien renvoyer, soit générer une erreur (exception) si l'item
n'est pas trouvé.
L'algorithme est :
Et là, je m'excuse bien bas auprès des puristes, cet organigramme n'a rien d'"officiel", il
manque le début et la fin, etc. L'idée est simplement d'avoir un exemple sous la main.
Ce qu'on cherche à faire, c'est rendre notre code source facile à analyser (pour un
humain s'entend). On parle beaucoup de la "maintenabilité" des programmes, qui consiste à
trouver le meilleur moyen de pouvoir modifier facilement un programme après coup. Cette
maintenabilité intervient aussi lors de l'écriture, bien avant que le programme soit terminé. Il
est très difficile, pour ne pas dire impossible de garder en tête l'intégralité des algorithmes et
principes utilisés dès lors qu'un programme s'étoffe (en tout cas de manière précise). Le
programmeur a ceci de particulier que lorsqu'il se replonge dans un programme sur lequel il n'a
pas travaillé depuis plusieurs mois, il est comme un martien qui descend sur terre et il a tout à
réapprendre. Ne négligez jamais la forme (je sais c'est dur !). Mettez des commentaires,
indentez et surtout structurez correctement. La partie la plus difficile étant de trouver la
structure la plus efficace pour votre programme, sans être trop astucieux (des astuces dont vous
vous poseriez la question de l'utilité après coup). En un mot comme en cent, voici quelques
maximes à afficher au plafond de votre chambre :
Être clair pour être rigoureux
Soyez clair et pas trop astucieux
Soyez rigoureux avant d'optimiser
Restez rigoureux en optimisant
Soyez clair avant d'optimiser
Restez simple pour optimiser
Écrire pour être lu
Polissez la forme pour aider le lecteur
Écrivez pour être lu de haut en bas
Commentez le code sans le trahir
Évitez l'excès de commentaires
Personnalisez et initialisez chaque variable
Être cartésien
Écrivez en clair un premier programme
Décomposez-le en blocs
Cantonnez chaque bloc à une action bien faite
Éclairez les liaisons entre bloc
Indentez pour exhiber la structure logique.
V.4. Maitre en forme
Comme il est dit plus haut, la mise en forme d'un code source est extrêmement importante. Il
existe plus ou moins des normes de fait issues de l'expérience des programmeurs et utilisées
avec quelques variantes par la majorité d'entre eux. N'oubliez pas qu'il s'agit de préférences
personnelles, et que rien ne vous oblige à les utiliser telles quelles. Simplement, vous aurez
comme tout le monde un style de présentation probablement différent au début, qui évoluera
avec l'expérience pour atteindre quelque chose qui ressemblera certainement fort à ce que je
vous présente ici, mais nul n'étant prophète en son pays... et puis les goûts et les couleurs, hein...
En tout cas, voici une exemple type d'une fonction qui pourrait être prélevée dans une unité :
Vous avez pu constater que l'éditeur (EDI) de Delphi ou de Turbo Pascal met en
valeur par du gras ou des couleurs les mots-clés, commentaires ou autre. Sachez que ces
couleurs sont entièrement configurables : à vous de choisir celle qui vous convient le mieux.
Je vous suggère d'ailleurs d'aller modifier ce paramétrage pour mettre en valeur les chaînes de
caractères, ce qui n'est pas le cas avec la configuration par défaut (dans Delphi 4 : Aller dans le
menu Outil/Options d'environnement, puis choisir l'onglet Couleurs).
V.5. Les majuscules
Il est d'usage d'écrire le code en minuscules et d'utiliser les majuscules pour rendre les noms
plus compréhensibles. Dans notre exemple, le nom de la fonction est FindItem, la
variable MustExist, etc.
V.6. Retour à la ligne, begin et end
D'une manière générale, on ne met jamais plus d'une instruction par ligne (un seul point-
virgule), et on effectue un retour à la ligne après un then. Néanmoins, pour ne pas trop
rallonger un code trop long, ou pour rendre plus clair sa structure, il est possible de ne pas
effectuer ce retour quand la ligne reste très courte.
JAMAIS ça :
if not Updated then Update; I := IndexOf(Name);
Exemples possibles :
if not Updated then Update;
ou (préférable)
if not Updated then
Update;
Quant au begin et au end, je positionne mes begin sur la même ligne que le else parce que ça
raccourcit la longueur du texte, mais attention aux oublis ! D'autres préfèrent aligner
verticalement systématiquement les begin et les end.
begin
if ... then
...
else
begin
...
end;
end;
ou
begin
if ... then
...
else begin
...
end;
end;
V.7. Les noms de variable
N'hésitez pas à fournir des noms de variable compréhensibles. Ne soyez pas fainéants, mais
n'en abusez pas ! Si vous avez par exemple une variable qui désigne le numéro de la couleur
maximum dans un tableau, évitez Numero De la Couleur Maximum. Numero Couleur
Maximum est peut-être encore trop long. Une bonne idée serait quelque chose comme
noCoulMax ou noCoulMax, ou encore NumCouleurMax.
V.8. Les commentaires
Nous en avons déjà parlé : utilisez-les à bon escient. Pour ma part j'ajoute systématiquement un
en-tête explicatif en début de fichier (projet, version, ...).
Je répète aussi le nom de la procédure et fonction après le "end;" de fin ( end; {FindItem} ).
Cela permet lorsqu'on est en bas du code de savoir sur quelle procédure on travaille.
VI. Les structures de boucle
Notre exemple avance. Maintenant, si nous désirons construire une phrase non plus avec trois mots,
mais avec cinq, nous n'allons tout de même pas répéter notre code cinq fois !!!
Pour cela, il suffit d'utiliser une des structures de boucle. Il en existe trois : le For ... to ... do ... (pour
<valeur initiale> jusqu'à <valeur finale> faire <ceci>), le while (tant que <condition>) et le repeat ...
until (répète <ceci> jusqu'à <condition>).
Le For et le while sont utilisés quand on connaît à l'avance le nombre de fois que la boucle doit être
exécutée. Dans le repeat ... until la condition de fin de boucle est à la fin, et on l'utilise quand la boucle
doit au moins être parcourue une fois.
Notre exemple avec un For :
Program MonDeuxiemeProg;
function ConstruitPhrase(phrase:string):string;
var s : string;
begin
readln(s);
ConstruitPhrase:=phrase+', '+s;
end;
var
Phrase : string;
i : integer;
begin
Phrase:=''; {initialiser à chaîne vide}
for i:=1 to 3 do begin
writeln('Entrez un mot :');
Phrase:=ConstruitPhrase(Phrase);
end;
{afficher le résultat}
writeln('La phrase complète est :');
writeln(Phrase);
writeln('Appuyer sur <entrée> pour quitter');
readln;
end.
Tout ce qui est entre le begin et le end du For est exécuté en boucle. N'oubliez pas la déclaration
de notre nouvelle variable i.
Avec un while :
[...]
i:=1; {initialiser i}
while i<>3 do begin
writeln('Entrez un mot :');
Phrase:=ConstruitPhrase(Phrase);
inc(i); {incrémente i à chaque tour}
end;
{afficher le résultat}
[...]
end.
Remarque : Dans ce cas vous voyez que vous êtes vous-même obligé d'incrémenter votre
compteur i. Ne pas oublier d'initialiser votre variable ni de l'incrémenter sinon votre programme
tournera indéfiniment.
Avec un repeat :
[...]
i:=1; {initialiser i}
repeat
writeln('Entrez un mot :');
Phrase:=ConstruitPhrase(Phrase);
inc(i); {incrémente i à chaque tour}
until i>3;
{afficher le résultat}
[...]
end.
On voit bien que dans ce cas, le plus efficace est le For. Mais alors, pourquoi utiliser un while
? Et bien parce qu'on ne peut mettre dans une boucle For qu'un compteur. Dans un while ou un
repeat, la condition pourrait être quelque chose de plus complexe, comme par exemple :
while length(phrase) <= 100; {
exécute la boucle tant que la longueur de la variable phrase
}
{ne dépasse pas 100 caractères}
ou encore :
until length(phrase) > 100; {
termine la boucle si la longueur de la variable phrase
}
{dépasse 100 caractères}
Si on change les règles du jeu, et que l'on veut demander à l'utilisateur quand il désire s'arrêter,
on pourrait utiliser un repeat :
[...]
var
Phrase : string;
reponse : char; {contiendra un caractère}
begin
Phrase:=''; {initialiser à chaîne vide}
repeat
writeln('Entrez un mot :');
Phrase:=ConstruitPhrase(Phrase);
writeln('Voulez-vous continuer ? (entrez o pour continuer) ');
readln(reponse);
until Upcase(reponse)<>'O'; {différent de o ou O}
{afficher le résultat}
[...]
end.
VI.1. Structures de test
Alors, reste un petit problème que vous aurez forcément remarqué : notre phrase commence
toujours par une virgule !
Pour corriger ça, il suffit simplement de n'ajouter la virgule que si la chaîne n'est pas vide. C'est
là toute l'utilité des tests :
[...]
function ConstruitPhrase(phrase:string):string;
var s : string;
begin
readln(s);
if phrase = '' then
ConstruitPhrase:=s
else
ConstruitPhrase:=phrase+', '+s;
end;
[...]
Ce qui se traduit en gros par :
Si phrase est vide alors
mettre s dans phrase
sinon
ajouter s à phrase et mettre le tout sans phrase
Remarquez qu'il n'y a pas de point-virgule après la ligne phrase:=phrase+s. En effet,
l'instruction du If ne se termine qu'après le else.
On peut aussi utiliser un if sans else :
[...]
function ConstruitPhrase(phrase:string):string;
var s : string;
begin
readln(s);
if phrase <> '' then
phrase:=phrase+', ';
ConstruitPhrase:=Phrase+s;;
end;
[...]
