Programmation en Pascal Notes de cours Licence de linguistique Universit Paris 7 e

Yan Jurski et Ines Klimann 5 novembre 2004

Ces notes reprsentent un premier jet. Nhsitez pas ` nous faire part dventuelles erreurs pour que e e a e nous les corrigions ou de doutes quelles pourraient susciter, pour que nous les rendions plus prcises, e en cours ou par courrier lectronique ` {jurski,klimann}@liafa.jussieu.fr. e a

Table des mati`res e

1 Utilit dun programme e 2 Mes premiers pas avec Pascal 2.1 Comment utiliser Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Mon premier programme en Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.3 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Constantes et variables, ou programme 3.1 Les constantes . . . . . . 3.2 Les variables . . . . . . . 3.3 Les types . . . . . . . . . comment ranger les valeurs qui apparaissent dans un . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 5 7 8 8 8 10 11 12 12 12 14 15 15 17 17 17 19 3 4 4 4 4

4 Procdures et fonctions e 4.1 Les procdures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 4.2 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Les passages par rfrence (ou par variable) . . . . . . . . . . . . . . . . . . . . . . . . ee 5 Les structures de contrle o 5.1 Tests . . . . . . . . . . . . . . . . . . . . 5.1.1 if ... then ... [else ... ] 5.1.2 case ... of ... else ... . . 5.2 Boucles . . . . . . . . . . . . . . . . . . 5.2.1 for ... to/downto... do... 5.2.2 repeat ... until ... . . . . . 5.2.3 while ... do ... . . . . . . . 5.2.4 Les sorties et sauts de boucle . . 6 Un peu de rcursivit e e

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

7 Les 7.1 7.2 7.3

types structurs e Dclaration dun nouveau type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e Tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Enregistrements (record) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

20 20 21 23

Utilit dun programme e

Imaginons quon ait un chier informatique contenant La disparition de G. Perec et quon veuille vrier queectivement il ne contient pas la lettre e. Une premi`re solution consiste ` le lire dun e e a bout ` lautre pour faire cette vrication. Outre que cette mthode prend du temps, elle est assez peu a e e able : emport par lanecdote, on peut tr`s bien laisser passer un e sans sen apercevoir. Une autre e e mthode consiste ` proter du fait quon a le texte sous forme informatique et ` faire cette vrication e a a e grce ` loutil informatique, en appliquant une mthode systmatique qui nous donne la rponse ` la a a e e e a question La disparition contient-elle un e?. Par exemple : Exemple 1 La disparition contient-elle un e ? version 1 Donne: un chier informatique contenant le texte de La disparition e dbut e contient un e := non; pour le caract`re courant du texte faire e si ce caract`re est un e alors e contient un e := oui nsi (avancer le curseur de lecture dun caract`re) e npour retourner contient un e; n On remarque que cette mthode nest pas tr`s ecace si G. Perec a par mgarde laiss chapp e e e ee e un e. En eet, d`s quon voit ce e, on peut alors arrter lexploration du texte et conclure. On peut e e donc imaginer une deuxi`me mthode (que nous appellerons un deuxi`me algorithme), donne dans e e e e lexemple 2. Exemple 2 La disparition contient-elle un e ? version 2 Donne: un chier informatique contenant le texte de La disparition e dbut e tant que le caract`re courant nest pas un e faire e (avancer le curseur de lecture dun caract`re) e ntq si on est ` la n du texte alors a retourner non sinon retourner oui nsi n Le but de la premi`re partie de ce cours est de pouvoir crire des programmes en langage Pascal e e qui permettent de faire ce genre de vrication (et dautres). Pour des raisons ayant trait ` votre e a formation, le cours sera centr sur le traitement de chiers textes, mais il est bien vident que lon e e peut programmer bien dautres choses que du traitement de donnes texte. e

2
2.1

Mes premiers pas avec Pascal

Comment utiliser Pascal

Pascal est un langage quil faut compiler : vous criver un chier texte lisible par un tre humain et e e un programme appel compilateur transforme ce chier en chier binaire, illisible pour un tre humain, e e mais tout ` fait comprhensible pour lordinateur sur lequel on vient dexcuter la compilation. a e e Plusieurs compilateurs sont disponibles, notament en fonction du syst`me dexploitation que vous e utilisez (DOS, Windows, Linux, etc.). Nous utiliserons un compilateur freepascal, disponible gratuitement sur internet ` ladresse a http://www.freepascal.org/ et dont il existe une version pour la plupart des syst`mes que vous pouvez tre amens ` utiliser. e e e a Sur un ordinateur sous Linux, une fois install, le compilateur peut tre invoqu grce ` la come e e a a mande fpc suivie du nom du code source (le chier texte dans lequel vous avez crit le programme). e Une fois la commande lance, le compilateur donne des informations concernant la compilation sur la e sortie standard. Il est important que vous lisiez les informations fournies par le compilateur, en eet, cest grce ` celles-ci que vous saurez si la compilation sest droule correctement ou a a e e que vous aurez des informations concernant les ventuelles erreurs dans votre programme. e

2.2

Mon premier programme en Pascal

A laide dun diteur de texte, par exemple emacs, crez un chier que vous nommerez premier.p e e et qui contiendra le texte suivant :

programme 1 : premier.p program premier; begin write(bonjour); end. indexmotsclefsbeginindexmotsclefswrite Dans un terminal, compilez ce programme en utilisant la commande fpc premier.p Si vous regardez le contenu de votre rpertoire (commande ls), vous vous apercevrez que plusieurs e nouveaux chiers ont t crs. Celui qui nous intresse se nomme premier, du nom de votre chier e e ee e de dpart sans lextension. Excutez votre programme en lanant la commande e e c ./premier et regardez ce qui se passe ` lcran. a e

2.3

Les commentaires

Quand on crit un programme, il ne faut pas oublier que celui-ci sera srement utilis par dautres e u e personnes et en tout cas par soi-mme; soit pour ce quil fait directement, soit pour le radapter ` un e e a probl`me proche. Cest pourquoi il est tr`s important de commenter ses programmes. Un minimum e e tant une description globale de ce que fait ce programme. On verra quun programme devient rae pidement long et qualors il faut entrer plus dans les dtails. On peut ainsi rcrire le programme 1 e ee en :

programme 2 : premier-commente.p { programme premier-commente.p ecrit par I. Klimann et Y. Jurski exemple de programme commente qui affiche bonjour a lecran } program premier-commente; begin write(bonjour); end. Il faut absolument prendre lhabitude de comment son code au fur et ` mesure de la programe a mation, car les commentaires peuvent aider ` structurer un programme. Il est par exemple tout a fait a possible dcrire quasi enti`rement un commentaire avant de sattaquer au code lui-mme; en revanche e e e il faut viter dcrire tout le code en se disant quon commentera apr`s. e e e

3
3.1

Constantes et variables, ou comment ranger les valeurs qui apparaissent dans un programme
Les constantes

Que se passe-t-il si on veut calculer le prim`tre dun cercle de rayon 4.5 ou estimer le nombre de e e mots dun texte de 237 pages, sachant quon a en moyenne 13 mots par ligne et 37 lignes par pages? On peut bien entendu crire les programmes suivants : e

programme 3 : perimetre 1.p { calcul du perimetre dun cercle de rayon 4.5 - version 1 } program perimetre_1; begin write(le perimetre dun cercle de rayon 4.5 est : ); writeln(2*3.1415*4.5); end.

programme 4 : nb de mots 1.p { estimation du nombre de mots dun texte de 237 pages, avec en moyenne 13 mots par ligne et 37 lignes par page - version 1 }

program nb_de_mots_1; begin writeln(On estime le nombre de mots a , 237*13*37, .); end. Dans ces deux programmes, ce qui peut tre amen ` changer, cest respectivement le rayon du e ea cercle et le nombre de pages du texte. On peut donc considrer les autres donnes (la valeur de e e dans le premier cas, le nombre de mots par ligne et de lignes par page dans le second) comme des constantes. On leur attribuera alors un nom, qui servira de la mme faon que les valeurs numriques, e c e mais aura plusieurs avantages : on na pas besoin de retenir les valeurs, si on veut modier ces valeurs (par exemple ajouter des dcimales ` pi ou changer de police e a de caract`res, ce qui modie a priori la taille des caract`res et donc le nombre de mots par e e ligne et ventuellement le nombre de lignes par page), il sut de changer ces valeurs une unique e fois, au moment o` lon fait lassociation entre le nom de la constante et sa valeur; cela vite u e doublier des changements ou de faire des changements qui nont pas lieu dtre (on peut tr`s e e bien imaginer que dans un programme on utilise le nombre de 13 pour autre chose et alors il ne faudra pas modier cette occurence-l`). a Les programmes prcdents deviennent alors : e e programme 5 : perimetre 2.p { calcul du perimetre dun cercle de rayon 4.5 - version 2 } program perimetre_2; const pi = 3.1415; begin write(le perimetre dun cercle de rayon 4.5 est : ); writeln(2*pi*4.5); end.

programme 6 : nb de mots 2.p { estimation du nombre de mots dun texte de 237 pages, avec en moyenne nb_mots_par_ligne mots par ligne et nb_lignes_par_page lignes par page - version 2 } program nb_de_mots_2;

const nb_mots_par_ligne = 13; nb_lignes_par_page = 37; begin writeln(On estime le nombre de mots a , 237*nb_mots_par_ligne*nb_lignes_par_page, .); end. Attention : Pascal ne distingue pas les majuscules des minuscules.

3.2

Les variables

Dans les programmes prcdents, on reste insatisfait par le fait que les quantits 4.5 (rayon du e e e cercle) et 237 (nombre de pages du livre) apparaissent en dur. On pourrait, comme pour les autres quantits, les faire appara comme des constantes, mais ce ne sont pas vraiment des constantes : si e tre on veut calculer le prim`tres de tous les cercles dont le rayon est compris entre 4 et 5, espac de 0.1, e e e ou si, une fois la police xe, on veut estimer le nombre de mots de plusieurs ouvrages, on na pas e forcment envie de crer une constante par rayon de cercle ou par ouvrage. En fait, dans ces cas-l`, on e e a a plutt besoin de bo o tes dans lesquelles mettre des valeurs qui seront amenes ` tre modies : ce e ae e sont les variables. Le nom dune variable est compos dune suite de caract`res comprenant les lettres, e e les chires et le caract`re underscore ( ). En aucun cas on ne peut mettre un espace dans le nom dune e variable (ni dans un quelconque identicateur), ni un signe moins (-). Le Pascal est un langage typ : quand on utilise une variable, il faut prciser quel est son type (par e e exemple si cest un entier, un rel, un caract`re, une cha de caract`res, etc.). Cette donne permet e e ne e e au langage davoir des traitements spciques suivant le type des donnes, par exemple : e e lachage dun entier se fait sans chire apr`s la virgule, alors que lachage dun rel se fait e e avec un certain nombre de chires apr`s la virgule, par dfaut, e e le symbole + entre deux entiers eectue lopration somme, le mme symbole entre deux cae e ract`res eectue lopration concatnation. e e e On pourra par exemple regarder ce que donne le programme 7.

programme 7 : typage.p { affichage et "somme" de divers types de variables } program typage; var i,j : integer; r,s : real; c,d : char; begin i := 3; j := 5; r := 3; s := 5; c := 3; d := 5; writeln(i=,i,

i+j=,i+j);

writeln(r=,r, writeln(c=,c, end.

r+s=,r+s); c+d=,c+d);

3.3

Les types

Il existe plusieurs types en Pascal, on a dj` vu les types entier (integer), rel (real) et caract`re ea e e (char). Voici un complment sur ces types et sur dautres types disponibles en Pascal. e INTEGER les entiers oprateurs disponibles : + - * div mod e REAL les rels e oprateurs disponibles : + - * / e BOOLEAN les boolens (deux valeurs : TRUE et FALSE) e oprateurs disponibles : AND OR NOT XOR e CHAR les caract`res (suivant lordre ascii) e STRING les cha nes de caract`res e Il ne faut pas confondre un type mathmatique avec sa reprsentation en Pascal. Par exemple, e e dun point de vue mathmatique, un rel peut avoir autant de chires apr`s la virgule quon veut, ce e e e nest pas le cas du type REAL en Pascal, puisque la place mmoire correspondant ` une variable de e a ce type est limite. De mme, une variable de type INTEGER ne peut prendre nimporte quelle valeur e e car elle est code sur 16 bits : quand on a atteint la plus grande valeur de ce type (215 1 = 32767), e on retombe sur la plus petite (215 = 32768) en ajoutant 1. Il existe bien entendu dautres types en Pascal et les types dj` cits ont dautres caractristiques, ea e e nous les verrons au fur et ` mesure des besoins. a

Procdures et fonctions e

Supposons quon veuille valuer le nombre de mots de plusieurs ouvrages et/ou acher ces valuations. e e Une premi`re solution est de faire du copi-coll du bout de programme quon a crit. Cette solution e e e e est ` proscrire : si on veut modier un dtail dans le programme, on serait amen ` le modier ` a e e a a plusieurs endroits, avec tous les risques derreur que cela comporte; de plus, si on ne conna pas ` t a lavance le nombre douvrages, cette mthode est tout bonnement impossible ` mettre en uvre. Le e a mieux est de pouvoir enfermer dans une bo te un morceau de code et dappeler cette bo ` chaque te a utilisation. Ce type de bo sappelle une fonction ou une procdure, suivant quelle renvoie ou non une valeur. te e

4.1

Les procdures e

On reprend lexemple du paragraphe prcdent. On consid`re le programme 8. e e e programme 8 : premiere procedure.p { programme premiere_procedure.p premier exemple dutilisation de procedure } program premiere_procedure;

procedure affiche_nb_de_mots(nb_pages : integer); const nb_mots_par_ligne = 13; nb_lignes_par_page = 37; begin writeln(nombre de mots estime : , nb_mots_par_ligne * nb_lignes_par_page * nb_pages, .); end; { affiche_nb_de_mots } begin {premier ouvrage : titre : Ouvrage 1, nombre de pages : 132} write(Ouvrage 1, ); affiche_nb_de_mots(132); {deusieme ouvrage : titre : Ouvrage 2, nombre de pages : 175} write(Ouvrage 2, ); affiche_nb_de_mots(175); end. Il serait plus satisfaisant de pouvoir fournir ` la procdure affiche nb de mots ` la fois le nombre a e a de pages de louvrage et son titre, ce qui simplierait dautant plus lcriture de la partie principale e du programme. Pour cel`, on utilise le type cha de caract`res, string en Pascal. a ne e

programme 9 : plusieurs ouvrages.p { programme plusieurs_ouvrages.p introduction des chaines de caracteres } program plusieurs_ouvrages; procedure affiche_nb_de_mots(titre : string; nb_pages : integer); const nb_mots_par_ligne = 13; nb_lignes_par_page = 37; begin writeln(titre, , nombre de mots estime : , nb_mots_par_ligne * nb_lignes_par_page * nb_pages, .); end; { affiche_nb_de_mots } begin {premier ouvrage : titre : Ouvrage 1, nombre de pages : 132} affiche_nb_de_mots(Ouvrage 1, 132); {deusieme ouvrage : titre : Ouvrage 2, nombre de pages : 175} affiche_nb_de_mots(Ouvrage 2, 175); end.

Exercice 4.1 Ecrire une procdure qui prend en argument une cha de caract`res correspondant e ne e au nom dun auteur, son anne de naissance, son anne de dc`s et le nombre de livres crits par e e e e e

cet auteur, et ache une phrase du type Tartampion est mort ` tel ge, apr`s avoir crit tant a a e e douvrages.. e On remarque sur le programme de lexercice 4.1 que si plusieurs arguments ont le mme type, on peut se contenter de mettre ` la suite les noms des arguments spars par des virgules et ne prciser a e e e le type quune unique fois, comme on le faisait en dclarant des variables de mme type. e e

4.2

Les fonctions

Si maintenant on ne veut plus acher un texte ` lcran, mais rcuprer le rsultat dun calcul, on a e e e e utilise une fonction. Le programme 10 montre comment on peut se servir de fonctions.

programme 10 : polices.p { programme polices.p compare le nombre de mots autorises suivant la taille de la police } program polices; function nb_de_mots_10_points(nb_pages : integer) : integer; const nb_mots_par_ligne = 18; nb_lignes_par_page = 38; begin nb_de_mots_10_points := nb_mots_par_ligne * nb_lignes_par_page * nb_pages; end; { nb_de_mots_10_points } function nb_de_mots_12_points(nb_pages : integer) : integer; const nb_mots_par_ligne = 13; nb_lignes_par_page = 37; begin nb_de_mots_12_points := nb_mots_par_ligne * nb_lignes_par_page * nb_pages; end; { nb_de_mots_12_points }

procedure comparaison(nb_de_pages : integer); var m10, m12 : integer; begin m10 := nb_de_mots_10_points(nb_de_pages); m12 := nb_de_mots_12_points(nb_de_pages); writeln(Si vous avez , nb_pages, pages, vous avez droit a :); writeln(* , m10, mots en 10 points,); writeln(* , m12, mots en 12 points.); writeln(Vous gagnez donc , m10-m12, mots en 10 points.); end;

10

begin comparaison(21); end.

Exercice 4.2 Ecrire une fonction longevite qui prend en argument les annes de naissance et de e dc`s de quelquun et renvoie lge de la personne au moment de sa mort. e e a

4.3

Les passages par rfrence (ou par variable) ee

Jusqu` prsent, tous les arguments des procdures et des fonctions que nous avons vus taient a e e e passe par valeur : cest en fait une copie de la valeur qui tait passe, le code de la procdure ou de e e e e la fonction appele ne pouvant altrer la valeur de la variable transmise. e e Testez le programme 11 pour voir ce qui se passe. programme 11 : valeur.p { exemple de procedure inutile } program valeur; procedure inutile(i : integer); begin i := 5 ; end; { inutile }

var v : integer; begin v := 3; writeln(au debut : v=, v); inutile(v); writeln(apres la procedure inutile : v=, v); end. En Pascal, on a la possibilit de faire un passage de param`tre par rfrence (ou par variable) : e e ee les oprations eectues sur le param`tre dans une procdure ou une fonction alt`rent eectivement e e e e e celui-ci. Pour cela, dans len-tte de la fonction, avant le nom de largument, on rajoute le mot-clef du e langage var. Comparer le programme 11 au programme 12.

programme 12 : reference.p { exemple de passage par reference } program reference;

11

procedure passage_par_reference(var i : integer); begin i := 5 ; end; { passage_par_reference }

var v : integer; begin v := 3; writeln(au debut : v=, v); passage_par_reference(v); writeln(apres la procedure passage_par_reference : v=, v); end.

Exercice 4.3 Ecrire une procdure echange qui prend en argument deux param`tres entiers et change e e e leurs valeurs.

Les structures de contrle o

Jusqu` prsent, tous les programmes que nous avons vu avaient un droulement linaire. Le but a e e e des structures de contrle est dintroduire un peu de varit. Dans la section 5.1 ddies aux tests, nous o ee e e verrons comment introduire des bifurcations dans ce droulement. Puis dans la section 5.2 ddies aux e e e boucles, nous verrons comment introduire des retours en arri`re dans ce droulement. e e

5.1
5.1.1

Tests
if ... then ... [else ... ]

Maintenant que lon sait faire des calculs, on aimerait bien pouvoir faire des tests, par exemple : si le lecteur a une bonne vue, on ache en 10 points, sinon on ache en 12 points.

programme 13 : test1.p { programme test1.p premiere utilisation du test if } program test1; function taille_police(vue : integer) : integer; begin if vue>=8 then taille_police := 10 { pas de point-virgule avant le else !!! } else taille_police := 12; end; { taille_police }

12

var acuite_visuelle : integer; begin writeln(Quelle est votre acuite visuelle ? ); read(acuite_visuelle); writeln(Pour vous, les textes seront affiches avec une taille de , taille_police(acuite_visuelle), points.); end. La syntaxe dun test if est la suivante : if condition then action1[;] [else action2;] Si la condition est vrie, alors laction1 est excute, sinon cest laction2 qui est excute, puis e e e e e e le programme passe ` la suite. La partie else est facultative; si elle est omise et que la condition nest a pas vrie, alors le programme passe ` la suite directement. e e a Attention : sil y a un else, alors la derni`re instruction avant ce else ne se termine pas par un e point-virgule. Une action est une compose soit dune unique instruction, soit dune suite dinstructions encadre e e par les mots-clefs begin et end. Quelle est la nature de condition? En fait condition est ce quon appelle un expression boolenne, e cest-`-dire une expression qui svalue soit en vrai (true), soit en faux (false). On peut en voir a e quelques exemples ci-dessous (attention, ce sont des morceaux de programme) : if true then write(a); {action toujours effectuee} ... {n est un entier auquel on a affecte une valeur} if n>=10 then writeln(au moins 10) else writeln(moins de 10); ... {est_adherent est une fonction qui prend en argument une chaine de caracteres et renvoie un booleen, numero_adherent est une fonction qui prend en argument une chaine de caracteres et renvoie un entier} if est_adherent(Alain) then writeln(numero dadherent : , numero_adherent(Alain)) else writeln(non adherent); Les oprateurs de comparaisons qui peuvent appara e trent sont les suivants : = <> (dirent de) < e <= > >=. Il sutilisent aussi bien avec des types numriques quavec des caract`res ou des cha e e nes de caract`res (dans ces 2 derniers cas, on consid`re lordre ascii). e e On peut galement mettre comme condition une expression boolenne plus complique, en eece e e tuant une opration entre des expressions simples. Les oprations sont celles vues ` la section 3.3 pour e e a les variables boolennes : and or not xor. e if (existe_ouvrage(Cours de Pascal)) and not (disponible(Cours de Pascal)) then write(Voulez-vous commander ce livre ?); Exercice 5.1 Ecrire une fonction est pair qui prend en argument un entier et renvoit true si cet entier est pair, false sinon.

13

Exercice 5.2 Ecrire une fonction est voyelle qui prend en argument un caract`re (quon suppose e tre une lettre de lalphabet, sans faire de vrication ` ce sujet) et renvoie true si cette lettre est une e e a voyelle, false si cest une consonne. Remarque : on peut tester si un caract`re reprsente une lettre minuscule en vriant quil appare e e tient ` lintervalle dlimit par a et z de la faon suivante : a e e c c : char; if c in [a..z] then ... Exercice 5.3 On suppose que dans un magasin de photocopies, trois tarifs sont achs : 0,20 e / phoe tocopie jusqu` 10 photocopies, 0,15 e / photocopie de 11 ` 100 photocopies et 0,10 e / photocopie ` a a a partir de 100 photocopies. Ecrire une fonction qui prend en argument le nombre de photocopies eectues et renvoie le prix e a ` payer. 5.1.2 case ... of ... else ...

Le test if est bien adapt quand un ensemble de valeurs pour une expression donne provoque un e e certain comportement du programme et que lensemble complmentaire provoque un autre compore tement. Si on veut spcier plusieurs comportement en fonction dune partition des valeurs possibles e en plus de deux sous-ensembles, il faut imbriquer les tests if, ce qui est tout ` fait possible, mais a fastidieux. Une mthode plus simple est mise ` notre disposition : le test case. e a La syntaxe de case est la suivante : case expression of value1.1, value1.2, . . . , value1.n1 : action1; value2.1, value2.2, . . . , value2.n2 : action2; ... valuep.1, valuep.2, . . . , valuep.np : actionp; else action par dfaut; e end; Remarque : le compilateur fpc nadmet pas que des cas se chevauchent (ce qui est autoris par le e Turbo Pascal). Tout comme pour le test if, une action est compose dune instruction unique ou bien dune suite e dinstructions entoure des mots-clefs begin et end. e Vous avez un exemple dutilisation de case dans le programme 14.

programme 14 : premier case.p { ma premiere utilisation de case } program premier_case; procedure action(); begin writeln(action effectuee);

14

end;

var rep : char; begin write(Voulez-vous effectuez une action (o/n) ? ); read(rep); case rep of o, O : action(); n, N : writeln(je ne fais rien); else writeln(mauvaise reponse...); end; { case } end. Exercice 5.4 Rcrire une version plus courte de la fonction est voyelle de lexercice 5.2. ee

5.2

Boucles

Une des caractristiques de la programmation est de pouvoir excuter des tches de faon rptitive. e e a c e e On a pour cela deux familles de mthodes : la rcursion qui fait lobjet de la section 6 et litration e e e qui fait lobjet de la prsente section. e Il sagit ici de faire des boucles dans lesquelles on excute une suite dinstructions. Il faut donc e savoir quand on arrte de boucler. e 5.2.1 for ... to/downto... do...

On utilise la boucle for quand on conna le nombre ditrations ` eectuer. On introduit alors un t e a compteur qui nous permet de conna le numro de litration en cours. tre e e La syntaxe dune boucle for est la suivante : for compteur := debut to / downto n do action On utilise to quand lindice va en augmentant et downto quand il descend.

programme 15 : boucle for.p { indices ascendant et descendant dans une boucle for } program boucle_for; procedure monter(n : integer); var i : integer; begin for i:=1 to n do write(i, );

15

writeln(); end; { monter } procedure descendre(n : integer); var i : integer; begin for i:=n downto 1 do begin write(indice , i); writeln( dans la boucle descendante); end; end;

begin writeln(essai de for ascendant :); monter(5); writeln(); writeln(essai de for descendant :); descendre(4); end.

Exercice 5.5 La i-`me lettre dune cha de caract`res est obtenue en ajoutant [i] apr`s le nom e ne e e dune variable contenant cette cha ne, la premi`re lettre ayant un indice 1 en Pascal. e On dispose dune fonction length qui prend en argument une cha de caract`res et qui renvoie ne e un entier contenant sa longueur (ie son nombre de lettres). Ecrire une fonction nombre de voyelles qui prend en argument une cha de caract`res et renne e voie le nombre de voyelles contenues dans cette cha ne. Pour cela, vous pouvez rcuprer la fonction e e est voyelle de lexercice 5.4. Exercice 5.6 Ecrire une fonction remplacer qui prend en argument un param`tre c de type char et e deux param`tres base et nouveau de type string supposs de mme longueur (aucune vrication ` e e e e a ce sujet ne doit tre faite) et recopie les occurences de c qui apparaissent dans base dans la cha e ne nouveau. Cette fonction doit renvoyer le nombre de caract`res ainsi mis ` jour. e a exemples : c base nouveau c base nouveau c base nouveau a hippos girafe o hippos girafe p hippos girafe nouveau retour nouveau retour nouveau retour girafe 0 giraoe 1 gippfe 2

16

5.2.2

repeat ... until ...

On utilise la boucle repeat quand on conna une condition darrt. t e La syntaxe dune boucle repeat est la suivante : repeat action until condition On remarque donc que laction qui appara dans une boucle repeat est toujours excute au t e e moins une fois. Dans une boucle, on peut avoir besoin dun compteur. Dans une boucle for, il appara naturelt lement, mais ce nest pas le cas dans une boucle repeat ou dans une boucle while (section 5.2.3). Dans ces derniers cas, on ne doit pas oublier de mettre ` jour le param`tre. Cela peut tre fait grce a e e a aux fonctions standards inc (qui incrmente le param`tre, cest-`-dire augmente sa valeur de 1) et e e a dec (qui dcrmente le param`tre, cest-`-dire diminue sa valeur de 1). e e e a Exercice 5.7 Ecrire une procdure qui demande ` lutilisateur un entier entre 0 et 20 : si lutilisateur e a rpond correctement, le mot merci sache, sinon la procdure continue ` demander un tel entier e e a tant que la rponse donne nest pas correcte. e e 5.2.3 while ... do ...

On utilise la boucle while quand on conna une condition de non arrt. t e La syntaxe dune boucle while est la suivante : while condition do action Si la condition dune boucle while est fausse d`s le dpart, laction de la boucle nest jamais e e excute. e e Exercice 5.8 Ecrire une fonction existe qui prend en argument un param`tre de type char et un e param`tre de type string et renvoie true si le caract`re appara dans la cha de caract`res et false e e t ne e sinon. Exercice 5.9 Ecrire un programme qui permet de jouer au pendu. On supposera que le mot ` trouver a est rentr en dur dans le programme. Vous pouvez vous servir des fonctions crites aux exercices 5.6 e e et 5.8. 5.2.4 Les sorties et sauts de boucle

Pour sortir dune boucle avant sa n normale, on utilise break : le reste de la boucle nest pas excut, le test de n de boucle pas valu et on passe directement ` la suite. e e e e a Pour sortir de lexcution courante de la boucle et sauter ` la suivante, on utilise continue : le e a reste du code correspondant ` lexcution courante nest pas excut, le test de n de boucle est valu a e e e e e avant de repasser (ventuellement) dans la boucle. e Des exemples sont fournis par les programmes 16 et 17.

17

programme 16 : break.p { utilisation de la sortie de boucle break } program sortie_break; function carre(n : integer):boolean; {teste si un entier est un carre} var i : integer; begin carre:=false; i:=1; while i*i<= n do begin if i*i=n then begin carre:=true; break; end; inc(i); end; end; function exemple(borne_inf, borne_sup : integer):integer; {renvoie le plus petit carre entre borne_inf et borne_sup } var i : integer; begin exemple:=-1; for i:=borne_inf to borne_sup do if carre(i) then begin exemple:=i; break; end; end; { exemple }

var borne_inf, borne_sup, res : integer; begin write(borne inf et borne sup : ); read(borne_inf); read(borne_sup); res:=exemple(borne_inf, borne_sup); if res=-1 then writeln(Pas de carre entre , borne_inf, et , borne_sup, .) else writeln(Le plus petit carre entre , borne_inf, et , borne_sup, est , res, .); end.

18

programme 17 : continue.p { utilisation du saut de boucle continue } program saut_continue; procedure compter(ch : string); var lg, i : integer; nb_mots, nb_lettres : integer; begin nb_mots:=1; nb_lettres:=0; lg:=length(ch); for i:=1 to lg do begin if ch[i]= then begin inc(nb_mots); continue; end; inc(nb_lettres); end; writeln(ch, : , nb_lettres, lettres, , nb_mots, mots.); end; { compter }

var ch : string; begin write(Ecrivez une phrase : ); read(ch); compter(ch); end.

Un peu de rcursivit e e

On a dj` vu plusieurs exemple de fonction ou procdure qui font appel ` une autre fonction ou ea e a procdure (par exemple les programmes 10, 16 ou encore le programme de lexercice 5.5). e Rien nempche quune fonction ou une procdure sappelle elle-mme, on parle alors de rcursivit e e e e e (ou de fonction/procdure rcursive). e e Un exemple est donn par le bout de programme 18; on suppose quon dispose dune fonction e est voyelle (voir exercices 5.2 et 5.4).

19

programme 18 : rec.p { exemple de fonction recursive ceci est un morceau de programme, on suppose deja acquis : - la fonction est_voyelle - le programme principal } function nb_voyelles(ch : string):integer; begin if length(ch)=0 then nb_voyelles:=0 else begin if est_voyelle(ch[1]) then nb_voyelles:=1+nb_voyelles(copy(ch, 2, length(ch)-1)) else nb_voyelles:=nb_voyelles(copy(ch, 2, length(ch)-1)); end; end; { nb_voyelles }

Exercice 6.1 Ecrire une procdure qui propose un menu avec deux possibilits pour lutilisateur : e e arrter ou continuer, chacune associe ` un numro. Si lutilisateur demande ` arrter, la e e a e a e procdure rend la main, sinon elle se relance. e

Les types structurs e

Pour linstant nous avons vu des types de base en Pascal (boolean, char, integer ou real essentiellement) et un type qui nexiste pas de base, mais qui nous est fourni (string). Le but de cette section est dapprendre ` crer nous-mmes des nouveaux types. a e e

7.1

Dclaration dun nouveau type e

On peut dclarer un nouveau type de la faon suivante : e c type nouveau type = ancien type; Dans le programme 19, on dnit un type entier qui nest autre quun synonyme du type integer e et quon utilise par la suite.

programme 19 : type.p { definition dun nouveau type : le type entier, synonyme du type integer } type entier = integer; var n : entier;

20

begin n:=3; writeln(n); end.

7.2

Tableaux

Quand on veut avoir un certain nombre de renseignements du mme type (par exemple 10 entiers), e on utilise des tableaux, en prcisant les indices des cases extrmales et le type de chaque case. e e exemple : { tableau dentiers, cases numerotees de 1 a 10 } T : array [1..10] of integer; Dans le programme 20, on suppose quon a un code qui ` une lettre de lalphabet en associe a une autre. Dans la fonction codage, on prend en argument une cha de caract`res et on renvoie la ne e cha code (pour simplier, on suppose quon se restreint ` des cha ne e a nes de caract`res constitues e e uniquement de lettres minuscules, despaces et de signes de ponctuation). La fonction initialisation est l` uniquement pour initialiser le code. a

programme 20 : code.p { exemple dutilisation de tableaux dans des codes } program code;

procedure initialisation(var code_engendre : array of char); var n : integer; c : char; begin c:=f; for n:=1 to 26 do begin if c>z then c:=a; code_engendre[n]:=c; inc(c); end; end; { initialisation }

function codage(phrase : string; code : array of char):string; var phrase_codee : string; i, len, num : integer; begin len:=length(phrase); for i:=1 to len do begin

21

num := ord(phrase[i]) - ord(a); phrase_codee := phrase_codee + code[num]; end; codage:=phrase_codee; end; { codage }

var mon_code : array [1..26] of char; ma_phrase : string; begin initialisation(mon_code); write(votre phrase : ); read(ma_phrase); writeln(phrase codee : , codage(ma_phrase, mon_code)); end. On remarque deux points particuliers : On ne renvoie pas de rsultat de type array .... Pour pallier ` ce probl`me, dans initialisation, e a e on prend un param`tre transmis par valeur. e Les param`tres de type array ... sont fournis aux fonctions et procdures sans spcication e e e de leur taille. Exercice 7.1 Ecrire une procdure qui prend en argument un param`tre de type tableau dentiers e e correspondant ` un numro de tlphone et demande ` lutilisateur de mettre ` jour son numro sil a e ee a a e nest pas correct. Exercice 7.2 Ecrire la fonction decodage qui prend en argument un code fourni de la mme faon e c que dans le programme 20 et une cha de caract`res et renvoie la cha de caract`res correspondant ne e ne e a ` largument dcod. e e Pour trouver le dcodage dun caract`re, on pourra procder de la faon suivante : on parcourt e e e c le tableau donnant le code jusqu` trouver la lettre souhaite, puis on transforme lindice du tableau a e en caract`re. e On peut bien entendu dnir un nouveau type tableau de tant de caract`res. Dans ce cas, ce e e nouveau type peut tre utilis comme type de retour dune fonction. Comparez les programmes 20 e e et 21.

programme 21 : code2.p { exemple dutilisation dun nouveau type "tableau" dans des codes } program code2; type t_code = array[1..26] of char;

22

function initialisation():t_code; var n : integer; c : char; code_engendre : t_code; begin c:=f; for n:=1 to 26 do begin if c>z then c:=a; code_engendre[n]:=c; inc(c); end; initialisation:=code_engendre; end; { initialisation }

function codage(phrase : string; code : t_code):string; var phrase_codee : string; i, len, num : integer; begin len:=length(phrase); for i:=1 to len do begin num := ord(phrase[i]) - ord(a) + 1; phrase_codee := phrase_codee + code[num]; end; codage:=phrase_codee; end; { codage }

var mon_code : t_code; ma_phrase : string; begin mon_code:=initialisation(); write(votre phrase : ); read(ma_phrase); writeln(phrase codee : , codage(ma_phrase, mon_code)); end.

7.3

Enregistrements (record)

Dans la section 7.2, on a utilis un nouveau type qui permet de stocker plusieurs informations de e mme type. Nous allons maintenant voir comment stocker plusieurs informations de types dirents. e e Imaginons quon veuille stocker des renseignements concernant un auteur (nom, prnom, date de e naissance, nombre duvres crites) : on peut commencer par crer un type date contenant trois entiers e e reprsentant la date, puis un type auteur contenant tous les renseignements ncessaires concernant e e

23

lauteur, comme dans le programme 22.

programme 22 : auteur.p { exemples denregistrements (record) } program p_auteur; type date

= record mm,jj,aa : integer; end; auteur = record nom, prenom : string; naissance : date; oeuvres : integer; end;

function saisie_date():date; var d : date; begin write(jour : ); readln(d.jj); write(mois : ); readln(d.mm); write(annee : ); readln(d.aa); saisie_date:=d; end; { saisie_date }

procedure affiche_date(d : date); begin write(d.jj, /, d.mm, /, d.aa); end; { affiche_date }

function saisie_auteur():auteur; var aa : auteur; begin writeln(Saisie dun nouvel auteur :); write(son nom : ); readln(aa.nom);

24

write(son prenom : ); readln(aa.prenom); write(sa date de naissance : ); aa.naissance:=saisie_date(); write(nombre doeuvres ecrites : ); readln(aa.oeuvres); saisie_auteur:=aa; end; { saisie_auteur }

procedure affiche_auteur(a : auteur); begin write(a.prenom, , a.nom, , ne(e) le ); affiche_date(a.naissance); writeln(, a ecrit , a.oeuvres, oeuvre(s).); end; { affiche_auteur }

var x : auteur; begin x:=saisie_auteur(); affiche_auteur(x); end.

Exercice 7.3 A laide dun tableau, rcrire une procdure affiche date qui ache la date sous un ee e format plus agrable, comme 14 juillet 1789 au lieu de 14/07/1789. e

25