Principes Et Méthodes de Programmation2 PDF

PASCAL
Principes et mthodes de programmation
Sommaire
1 Introduction................................................................................................................1 1.1 Pourquoi le langage Pascal?..............................................................................1 1.2 Un peu d'histoire.................................................................................................1 1.3 Pascal et C..........................................................................................................1 1.4 Le Pascal en micro-informatique........................................................................2 1.5 C'est en programmant que l'on devient programmeur .......................................3 2 Gnralits................................................................................................................ 1 2.1 Concepts informatiques......................................................................................1 2.2 La programmation structure............................................................................. 2 2.3 Structure d'un programme Pascal......................................................................3 2.3.1 L'en-tte....................................................................................................... 3 2.3.2 Les dclarations...........................................................................................3 2.3.3 Le corps du programme...............................................................................4 2.4 Les units lexicales d'un programme Pascal..................................................... 4 2.4.1 Gnralits...................................................................................................4 2.4.2 Le jeu de caractres Pascal.........................................................................4 2.4.3 Les identificateurs........................................................................................ 5 2.4.4 Les identificateurs prdfinis....................................................................... 7 2.4.5 Les mots-cl.................................................................................................8 2.4.6 Les symboles............................................................................................... 8 2.4.7 Les constantes............................................................................................. 9 2.4.8 Les commentaires......................................................................................10 2.4.9 Rgles gnrales du langage Pascal........................................................ 11 3 Les variables: premire partie...................................................................................1 3.1 Introduction.........................................................................................................1 3.2 Dclaration..........................................................................................................1 3.3 Les types de variables........................................................................................1 3.4 Prise de valeurs ou affectation........................................................................... 4 3.5 Les types simples............................................................................................... 4 3.5.1 Le type entier............................................................................................... 4 3.5.2 Le type boolen............................................................................................5 3.5.3 Le type caractre......................................................................................... 5 3.5.4 Le type rel...................................................................................................7 D.VIESLET Principes et mthodes de programmation -3 Rv. 443
3.6 Les types structurs............................................................................................8 3.6.1 Le type chane de caractres.......................................................................8 4 Les entres sorties conversationnelles.....................................................................1 4.1 WRITE et WRITELN........................................................................................... 1 4.2 READ et READLN.............................................................................................. 5 5 Les oprateurs...........................................................................................................1 5.1 Oprateur daffectation.......................................................................................1 5.2 Oprateurs arithmtiques................................................................................... 2 5.3 Oprateurs logiques........................................................................................... 4 5.4 Oprateurs de comparaison...............................................................................4 5.5 Oprateurs de chane de caractres..................................................................5 5.6 Oprateurs de pointeurs.....................................................................................5 5.7 Oprateurs boolens..........................................................................................6 5.8 Oprateurs d'ensembles.....................................................................................6 5.9 Oprateurs divers............................................................................................... 6 5.10 Rgles de priorit..............................................................................................7 6 Les procdures et fonctions prdfinies................................................................... 1 6.1 Introduction.........................................................................................................1 6.2 Les routines mathmatiques.............................................................................. 1 6.3 Les routines pour scalaires.................................................................................4 6.4 Les routines pour caractres et chanes............................................................ 5 6.5 Les routines pour dates et heures......................................................................9 7 Les structures alternatives........................................................................................ 1 7.1 La structure IF ... THEN ... ELSE...................................................................... 1 7.2 La structure CASE ... OF ... ELSE......................................................................7 8 Les structures itratives............................................................................................ 1 8.1 La structure FOR ... DO......................................................................................1 8.2 La structure WHILE ... DO..................................................................................4 8.3 La structure REPEAT ... UNTIL........................................................................10 9 Les variables: deuxime partie..................................................................................1 9.1 Introduction.........................................................................................................1 9.2 Les types simples............................................................................................... 1 9.2.1 Le type numr..........................................................................................1 9.2.2 Le type intervalle..........................................................................................6 9.3 Les types structurs............................................................................................8 9.3.1 Le type tableau.............................................................................................8
-4 Rv. 443
D.VIESLET
9.3.2 Le type chane de caractres.....................................................................17 9.3.3 Le type ensemble.......................................................................................19 9.3.4 Le type enregistrement.............................................................................. 25 9.3.5 Le type fichier.............................................................................................40 10 Les procdures et fonctions dfinies.......................................................................1 10.1 Introduction.......................................................................................................1 10.1.1 Les procdures.......................................................................................... 1 10.1.2 Les fonctions..............................................................................................2 10.2 Les routines sans argument............................................................................. 3 10.2.1 Les procdures.......................................................................................... 3 10.2.2 Les fonctions..............................................................................................3 10.2.3 Procdures et fonctions............................................................................. 4 10.2.4 Modification du droulement des routines.................................................5 10.3 La porte des variables.................................................................................... 5 10.3.1 Les variables globales................................................................................5 10.3.2 Les variables locales..................................................................................6 10.4 Les routines avec arguments........................................................................... 8 10.4.1 Les arguments transmis par valeur............................................................8 10.4.2 Les arguments transmis par adresse...................................................... 11 10.4.3 Les arguments constants.........................................................................14 10.4.4 Les arguments mixtes..............................................................................14 10.5 Les routines imbriques ou sous-routines......................................................16 10.6 La rcursivit...................................................................................................21 10.6.1 Introduction.............................................................................................. 21 10.6.2 La rcursivit simple................................................................................ 21 10.7 Les effets de bord........................................................................................... 27 10.8 Synthse sur les procdures et fonctions...................................................... 28
D.VIESLET
-5 Rv. 443
Exercices
Cadre.............................................................................................................................4 Correct ou pas...............................................................................................................7 Ma premire chane.......................................................................................................8 Comment vous appelez-vous ?.....................................................................................7 La priorit.......................................................................................................................8 Les parenthses inutiles................................................................................................8 Le prix total TVA Comprise...........................................................................................8 Le prix total du stock......................................................................................................8 Le prix de l'eau..............................................................................................................8 Quizz 1...........................................................................................................................5 Pair ou impair ?.............................................................................................................6 Les examens.................................................................................................................6 L'ge du capitaine.........................................................................................................6 Le colis postal................................................................................................................7 Le colis postal amlior.................................................................................................7 Quizz 2.........................................................................................................................11 Conversion de devises................................................................................................14 Le salaire d'un reprsentant........................................................................................14 Les charges professionnelles forfaitaires....................................................................15 La table de multiplication...............................................................................................3 L'alphabet......................................................................................................................3 La moyenne de la classe (FOR)....................................................................................3 Les toiles en ligne (FOR).............................................................................................3 Les toiles en triangle (FOR)........................................................................................4 La factorielle (FOR).......................................................................................................4 Le nombre premier (FOR).............................................................................................4 La division......................................................................................................................7 Le mois..........................................................................................................................7 La moyenne de la classe (WHILE)................................................................................7 Les toiles en ligne (WHILE).........................................................................................7 Les toiles en triangle (WHILE).....................................................................................8 La factorielle (WHILE)...................................................................................................8 Le nombre premier (WHILE).........................................................................................8 La racine carre (WHILE)............................................................................................10 La racine n-ime (WHILE)...........................................................................................10 -6 Rv. 443 Principes et mthodes de programmation D.VIESLET
Le nombre mystrieux.................................................................................................12 Un peu de statistique...................................................................................................12 La moyenne de la classe (REPEAT)...........................................................................12 Les toiles en ligne (REPEAT)....................................................................................13 Les toiles en triangle (REPEAT)................................................................................13 La factorielle (REPEAT)..............................................................................................13 Le nombre premier (REPEAT)....................................................................................13 La racine carre (REPEAT).........................................................................................14 La racine n-ime (REPEAT)........................................................................................14 Le minimum et le maximum........................................................................................11 Les valeurs uniques.....................................................................................................11 Le lotto.........................................................................................................................12 Le jeu de ds...............................................................................................................12 Le tableau dans tous les sens.....................................................................................12 La moyenne de la classe.............................................................................................12 Les deux tableaux.......................................................................................................13 Le tableau alatoire.....................................................................................................16 Le d............................................................................................................................17 Le dterminant.............................................................................................................17 Le systme d'quations...............................................................................................17 Le mot l'envers.........................................................................................................19 Une phrase..................................................................................................................19 Une autre phrase.........................................................................................................19 Les ensembles............................................................................................................22 Le numro de tlphone.............................................................................................24 Le nombre hexadcimal..............................................................................................24 Les voyelles et les consonnes.....................................................................................24 La saison.......................................................................................................................6 Le minimum et le maximum par procdure...................................................................6 Les variables locales et globales...................................................................................8 Le minimum et le maximum par fonction....................................................................10 Comparer deux mots...................................................................................................10 Les variables et arguments.........................................................................................12 Les variables et arguments (Bis).................................................................................13 Les variables et arguments (Ter)................................................................................14 Encore le minimum et le maximum.............................................................................14
D.VIESLET
-7 Rv. 443
Les racines..................................................................................................................16 Le nombre d'appels.....................................................................................................23 La puissance...............................................................................................................23 La puissance par dichotomie.......................................................................................24 Le tableau tri..............................................................................................................24 Les tours de Hano......................................................................................................26
-8 Rv. 443
D.VIESLET
1 Introduction
1.1 Pourquoi le langage Pascal?
Le langage Pascal offre une trs bonne approche de la programmation. Il est trs didactique donc indiqu l'apprentissage de la programmation. Il est bien adapt l'enseignement et donc trs utilis dans le milieu scolaire. Il permet d'acqurir des concepts de programmation solides que l'on retrouve dans tous les autres langages. Ce document est destine en premier lieu aux non-initis, tous ceux qui dbutent dans en programmation. Que ce soit dans le cadre de l'enseignement ou pour votre propre intrt personnel, vous avez dcid d'apprendre ce langage qui a le mrite de former la logique informatique. Le langage Pascal est trs structur et constitue en lui-mme une trs bonne approche de la programmation. Vous dcouvrirez dans les pages qui vont suivre, les bases de la programmation en gnral: les structures de boucle et de contrle, l'utilisation de la logique boolenne, la chronologie d'excution du code... Ces notions de base vous serviront si vous dcidez de changer de langage de programmation, car les principes de base (et mme les instructions de base) sont les mmes.
1.2 Un peu d'histoire

Ce langage a t cr en 1969 l'cole polytechnique de ZURICH par N. WIRTH. Il a t conu pour permettre d'enseigner la programmation comme une science. Ce langage est la base d'une nouvelle mthode de programmation: la programmation structure, et c'est pour cette raison que ce langage a eu un tel succs dans l'enseignement. Il s'agit d'un langage de 3 me gnration. En 1975, PASCAL a trs largement pntr le monde de la recherche et des universits. Pour son dveloppement, PASCAL devait tre accept dans le monde industriel, ce qui a t plus ou moins bien russi grce a:

De bonnes relations entre les universits et les industries (aux USA !). Les caractristiques propres PASCAL (simplicit, fiabilit). L'effort du DoD (dpartement de la dfense amricaine). Ds 1975, il y a cration d'un groupe de travail (High Order Language Working Group) charg de dterminer les caractristiques d'un langage de haut niveau bien adapt au dveloppement de ses applications militaires et permettant d'apporter des rponses 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 prhistoire, Pascal a t adopt par de nombreux constructeurs comme langage de dveloppement (CRAY Computer, ICL, Texas Instruments...), et surtout, le compilateur PASCAL a t rapidement disponible sur les micro-ordinateurs.
1.3 Pascal et C
Le langage C est un des langages les plus utiliss actuellement. Cela est d au fait que le langage C est un langage comportant des instructions et des structures de haut niveau (contrairement l'assembleur par exemple) tout en gnrant un code trs rapide grce un compilateur trs performant.
D.VIESLET
Principes et mthodes de programmation Introduction
1 -1 Rv. 443
Cela est d en ralit au fait que les instructions du langage sont faites de telle faon 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 spcifications... Ainsi, les programmes en C sont assez courts. La contrepartie est bien videmment que le langage C reste un langage assez compliqu. Toutefois, son apprentissage est dsormais ncessaire pour quiconque s'intresse la programmation, et cet apprentissage vaut le coup! " Pareil pour le Pascal, mais en un peu moins. Le Pascal est un langage de dveloppement le plus utilis pour l'enseignement, et un des plus utilis en programmation professionnelle sur micro-ordinateur. D'une manire gnrale, il se raconte que le PASCAL est le langage des "amateurs" et le C celui des professionnels. Cela nerve beaucoup la multitude de trs bons programmeurs en PASCAL, et valorise les dveloppeurs C (qui peuvent d'ailleurs tre tout aussi bons !). La grande famille des PASCALIENS est extrmement vivante, travers des forums et des listes de diffusion. Le Pascal permet de manipuler tout type de variable au mme titre que le C, sauf en ce qui concerne les accs directs la mmoire (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 cohrente, avec la dfinition systmatique des variables et des types, ce qui permet d'avoir un contrle maximum l'excution. Le fait que le recours aux pointeurs ne soit pas sa tasse de th oblige faire ds le dpart une bonne analyse, en forant le programmeur respecter sa philosophie et garder une bonne transposition algorithme/programme. Le code est relativement compact mais permet une trs bonne lisibilit, donc une maintenance aise (en thorie...). Enfin, la structuration permet de dcouper le programme en units de travail, chacune ayant ses propres variables et types. La conception descendante de la structure du programme permet ce dcoupage et augmente la logique de la structure et la lisibilit. Il y a beaucoup moins de possibilits d'crire un programme en Pascal qu'un programme en C, car l'utilisation outrance des astuces de programmation (rendant le code illisible) est limite. La rapidit d'excution d'un programme crit en Pascal est trs bonne, peine moins leve que celle d'un (bon) programme crit en C, et la taille des excutables est relativement compacte, bien que cet aspect soit de plus en plus anodin au regard des applications Windows o la taille du programme est conditionne par les "ressources", c'est dire les images et autres icnes.
1.4 Le Pascal en micro-informatique

L'essor du Pascal a suivi celle de la micro-informatique, grce notamment Philippe Khan, Franais bien connu qui a le premier commercialis un compilateur performant et fiable: Turbo Pascal. Il a fond la socit BORLAND et est actuellement le PDG (CEO) de la socit 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 spar (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, 1 -2 Rv. 443 Principes et mthodes de programmation Introduction D.VIESLET
BORLAND en faisant vivre son Turbo Pascal n'a cess d'apporter des amliorations 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 coteuses 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 perfectionnes, jusqu' la 6 qui dispose d'un environnement fentre (sous DOS of course), d'une programmation Objet et d'une bibliothque nomme Turbo Vision, sorte de Windows-Like en mode texte, qui permet de dvelopper des applications supportant la souris, les boutons, la touche tabilation, les raccourcis claviers, etc. La version 7 est dclin 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 dj 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 rponse de BORLAND fut quasi instantane, et une bande de programmeurs gniaux inventa "Delphi" en 1995, environnement hrit de Turbo Pascal. Delphi marqua immdiatement des points grce un compilateur performant gnrant du vrai code machine (contrairement Visual Basic qui tait un interprteur ou un pseudocompilateur), un environnement "bidirectionnel" (l'ajout d'un objet sur une fentre par glisser/dposer provoque l'criture automatique de code et inversement), une trs bonne transition avec le Turbo Pascal Objet, et la fameuse VCL (Visual Component Library) dont les sources sont livres et qui sont une mine d'information et de formation aux programmeurs de tout poil. Delphi 16 bits est toujours livr en mme temps que la dernire version, Delphi 5 qui permet de gnrer des applications pour les Windows 32 bits (95, 98, NT, 2000). Rcemment, BORLAND a chang de nom pour INPRISE, et cible dsormais le monde des entreprises avec des solutions Client/Serveur, Multi-Tier, Web.
1.5 C'est en programmant que l'on devient programmeur

Vous pourrez vous exercer en recopiant les exemples donns et en ralisant les exercices proposs tout au long de ce document. Pour cela, vous devrez utiliser un outil de dveloppement. Celui-ci pourra tre un simple compilateur ou un environnement de dveloppement intgr comprenant le compilateur, un diteur de texte, un outil de mise au point (couramment appel dbogueur ), ... Certains de ces outils sont gratuits et peuvent tre installs librement. Parmi eux, on trouve:

Dev-Pascal de BloodShed Software FreePascal
D'autres sont payants et demandent l'acquisition d'une licence d'utilisation. Parmi eux, on trouve:

TurboPascal (version 1 7) de Borland Delphi (version 1 la version actuelle 2010) de Borland Xilix de Borland
D.VIESLET
1 -3 Rv. 443
Des diffrences peuvent exister entre les diffrents outils et mme entre les versions d'un mme outil. Ces diffrences portent essentiellement sur la manipulation, les fonctions prdfinies et sur les types de variables. Le prsent document n'est pas un mode d'emploi de l'un ou l'autre de ces outils. Il est un guide destin l'apprentissage des principes de programmation en utilisant le langage Pascal. Il se bornera donc essentiellement aux lments communs aux diffrents outils et faisant partie de la norme. Quand une spcificit de l'un ou l'autre outil est utilise, elle sera mentionne. Pour pouvoir exploiter pleinement les possibilits de l'outil de dveloppement choisi, il faudra aussi se rfrer au mode d'emploi ou l'aide fournis par l'diteur.
1 -4 Rv. 443
D.VIESLET
2 Gnralits
2.1 Concepts informatiques
Un programme est une succession d'instructions destines tre excutes par un ordinateur, dans un certain ordre, afin de produire un rsultat spcifique. Les commandes comprises par un ordinateur sont, d'une manire interne, exprimes dans un code binaire (succession de 0 et de 1). Un langage de programmation est un langage qui permet au programmeur de donner des commandes non ambigus l'ordinateur. Il existe diffrents types de langages:
Le langage machine: c'est le seul langage compris par la machine. Son usage est complexe et spcifique chaque processeur. Il est constitu de symboles binaires. Le langage d'assemblage (ou Assembleur) : il est directement inspir du langage de la machine. Il en est trs proche mais est plus clair. Il est constitu de texte et non de symboles binaires. Il est lui aussi spcifique chaque processeur. Les langages volus: ils sont proches du langage de l'homme. Le programme se prsente sous la forme d'un texte appel code source contenant des instructions du porgramme. Un compilateur se charge de traduire ce langage en langage machine. Quelques exemples: COBOL, PASCAL, FORTRAN, C.
La squence des tapes ou oprations qui doivent tre suivies par le programme est l'algorithme du programme. L'algorithme est la spcification pas pas du processus qui doit rsoudre le problme pos. Il doit tre clair et non ambigu. Cet algorithme est transmis l'ordinateur au travers du langage de programmation. Le langage PASCAL appartient la famille des langages structurs. Ceux-ci sont des langages qui permettent l'laboration des programmes partir d'un ensemble de blocs d'instructions. Les programmes crits au moyen d'un tel langage peuvent tre raliss partir de quatre structures de base: la squence, la structure conditionnelle, la structure itrative (appele aussi rptitive), les procdures et fonctions.

La squence est un groupe d'instructions excutes les unes aprs les autres La structure conditionnelle permet une instruction ou un groupe d'instructions d'tre excut ou non en fonction des valeurs des donnes. La structure itrative est utilise pour excuter une instruction ou un groupe d'instructions plusieurs fois. Alors que les instructions sont les mmes chaque fois que la boucle est excute, les donnes sur lesquelles elles agissent changent d'une fois l'autre. Les procdures et fonctions permettent de remplacer un groupe d'instructions par un nom qui identifie ce groupe. Les procdures permettent de donner aux programmes une structure modulaire, ce qui rend l'criture plus facile et plus dense.
D.VIESLET
Principes et mthodes de programmation Gnralits
2 -1 Rv. 443
2.2 La programmation structure

Un ordinateur peut tre assimil un systme produisant des rsultats partir d'informations fournies et de "marches suivre" permettant de les traiter. Les informations sont constitues par des donnes, et les mthodes de traitement par des algorithmes. Pour obtenir des rsultats, la description des donnes et les algorithmes doivent tre cods sous forme de programmes excutables par l'ordinateur. En effet, le processeur de celui-ci ne peut excuter qu'un nombre relativement restreint d'instructions lmentaires (le code machine). Les programmes sont donc le rsultat d'une succession d'tapes comprises entre la spcification informelle du problme et sa codification. Il y a ainsi entre ces deux ples un "trou" qu'il s'agit de combler. Parmi les moyens ou les outils permettant d'y parvenir, on peut citer notamment des environnements de production de logiciel, des mthodes fournissant un encadrement au concepteur ou encore des langages de spcification permettant de prciser les tapes intermdiaires. Un autre aspect du rapprochement de la phase de codification vers la spcification du problme est constitu par le dveloppement ou l'utilisation de langages de programmation permettant un niveau d'abstraction plus lev. Un des objectifs de la programmation structure est la conception de logiciel fiable, efficace et d'une maintenance plus aise. Il peut tre atteint de manire asymptotique et par divers moyens. Les trois caractristiques cites peuvent difficilement tre values dans l'absolu, car elles dpendent souvent de critres relatifs et subjectifs. Un programme n'est pas juste ou faux; sa qualit est une notion globale, constitue par plusieurs lments, dont nous allons tudier les plus importants. La fiabilit est une proprit informelle et parfois difficile cerner. Cette proprit peut tre atteinte grce deux qualits du langage de programmation. D'abord, la facilit d'criture doit permettre d'exprimer un programme de faon naturelle ou en terme du problme rsoudre. Le programmeur ne doit pas tre drang par des dtails ou des habitudes du langage, mais doit pouvoir se concentrer sur la solution recherche. Les langages modernes de haut niveau tendent vers cet objectif. Ensuite, la lisibilit du programme doit permettre d'en saisir aisment la construction logique et de dtecter plus facilement la prsence d'erreurs. Dans cette optique, l'instruction GOTO, par exemple, rend difficile la lecture du programme de faon descendante. Toutefois, dans certains cas, les objectifs noncs au dbut de cette section peuvent tre atteints dans de meilleures conditions par l'utilisation d'un GOTO (bien plac et bien document) plutt que par une construction structure; sa prsence est alors acceptable. De telles situations sont toutefois extrmement rares. Si l'efficacit tait au dbut l'objectif principal de la conception d'un programme, actuellement cette notion a volu pour englober non seulement des critres de vitesse d'excution et de place mmoire, mais aussi l'effort requis par la maintenance du logiciel. En effet, la ncessit de la maintenance impose au logiciel qu'il soit lisible et modifiable. Ces qualits sont souvent lies des critres esthtiques. On peut nanmoins citer quelques facteurs qui facilitent les interventions dans un programme: un dcoupage appropri, une mise en page claire, un choix adquat des noms d'objets utiliss, des commentaires cohrents placs judicieusement.
2 -2 Rv. 443
D.VIESLET
2.3 Structure d'un programme Pascal

Un programme Pascal se compose de trois parties: EN-TETE DECLARATIONS PROGRAM identificateur; USES .....;{Nom des librairies} CONST identificateur = valeur; {dclaration des constantes} TYPE .........; {dclaration des types} VAR identificateur:type; {dclaration des variables} PROCEDURE ........; {dclaration des procdures} FUNCTION ........; {dclaration des fonctions} BEGIN {marque le dbut du programme} Instruction1; Instruction2; ............. {Suite d'instructions constituant le programme} ............. END. {marque la fin du programme}
CORPS DU PROGRAMME
2.3.1 L'en-tte
L'en-tte est facultatif mais vivement conseill. Il permet de donner un nom au programme. Il est constitue du mot-cl PROGRAM suivi d'un identificateur donnant le nom du programme. L'en-tte se termine imprativement par un pointvirgule. Un mot-cl est un mot qui est rserv par le langage Pascal. Un identificateur est un nom choisi par le programmeur pour donner un nom un lment du programme. Cet identificateur doit rpondre certaines rgles nonces au paragraphe 2.4.3 Les identificateurs. Le nom choisi donnera de prfrence une indication quant au le rle du programme. Exemples:
Program Calcul_Racine_Cubique; Program Superficie_Cercle; Program Facturation; ........
Bien que tout fait corrects au point de vue de la syntaxe du langage Pascal, ces noms sont viter:
Program Program Program Program Program P1; P24572; Truc; azerty;
x4v_t31a78yugh456b2dfgt;
Ce n'est pas trs clair !!! L'en-tte peut galement spcifier le nom des fichiers externes utiliss par le programme.
2.3.2 Les dclarations

Cette partie permet de dclarer tous les identificateurs utiliss dans la partie corps du programme. Elle s'tend de la fin de l'en-tte jusqu'au premier mot BEGIN. D.VIESLET Principes et mthodes de programmation Gnralits 2 -3 Rv. 443
Elle se divise en plusieurs sections diffrentes. Dclaration des:

Librairies Constantes Types Variables Procdures Fonctions tiquettes
Les diffrentes sections peuvent apparatre dans n'importe quel ordre. Il n'est pas indispensable que les programmes contiennent chaque fois toutes les sections.
2.3.3 Le corps du programme

La partie corps est la dernire partie du programme. Elle spcifie les actions ou instructions que le programme doit excuter. Les instructions du programme sont des commandes prcisant l'ordinateur ce qu'il doit faire pour raliser les tches attribues. Chaque instruction se termine par un point-virgule ; (sauf exceptions qui seront mentionnes par aprs). Le corps du programme commence par le mot rserv BEGIN suivi par une liste d'instructions spares par des ; et se termine par le mot rserv END suivi d'un point . .
2.4 Les units lexicales d'un programme Pascal

2.4.1 Gnralits
Un programme est crit dans un langage (de programmation). Ce langage est compos de mots, symboles, commentaires... Ceux-ci sont groups en phrases (dont l'ensemble compose le programme) qui obissent des rgles. Ces rgles dterminent de manire absolument stricte si une phrase est correcte ou non (respect de la syntaxe). L'analogie avec les langues naturelles (franais, allemand...) est donc forte, la principale diffrence tant qu'une phrase franaise peut tre forme de manire beaucoup moins rigoureuse et signifier nanmoins quelque chose. Or une phrase en Pascal doit tre absolument juste pour tre comprise par le compilateur ou l'interprte, sans quoi elle est obligatoirement rejete! Un programme Pascal est compos de phrases appeles units syntaxiques. Elles sont elles-mmes constitues de mots, symboles... appels units lexicales. Chaque unit lexicale est une suite de caractres appartenant au jeu de caractres Pascal.
2.4.2 Le jeu de caractres Pascal

Le jeu de caractres Pascal comporte les caractres suivants:

les chiffres 0 1 2 3 4 5 6 7 8 9 les lettres minuscules et majuscules a b c... z A B C... Z le caractre espace appel aussi blanc le caractre de tabulation ( HT ) le caractre soulign _ Principes et mthodes de programmation Gnralits D.VIESLET
2 -4 Rv. 443
les caractres spciaux suivants: parenthse gauche parenthse droite crochet gauche crochet droit accolade gauche accolade droite plus moins fois, toile divis, barre oblique infrieur (plus petit que) gal suprieur (plus grand que) deux-points point-virgule point virgule apostrophe chapeau, flche dollar dise
( ) [ ] { } + * / < = > : ; . , ' ^ $ #
Ajoutons que les constantes caractre et chanes de caractres (cf. 2.5.3) peuvent tre formes de n'importe quel caractre ASCII imprimable.
2.4.3 Les identificateurs

Les identificateurs sont des noms d'entits dfinis par l'utilisateur (programme, constantes, variables, procdures, fonctions, types...). Le programmeur dfinit ces identificateurs dans une partie spcifique du programme, le bloc des dclarations. Rgles d'criture Un identificateur devra respecter les rgles suivantes:
Il ne doit contenir que les 26 lettres de l'alphabet, des chiffres et le caractre soulign _ . Sont donc interdits: Principes et mthodes de programmation Gnralits 2 -5 Rv. 443
D.VIESLET
l'espace ; il sert de sparateur. les symboles plus + , moins ou tiret - , astrisque * , barre oblique / , gal = , point . , virgule , , deux points : , point-virgule ; , dollar $ , parenthses ( ) , accolades { } , crochets [ ] , apostrophe ' , l'arobase @ , suprieur > , infrieur < .......; ils ont une signification particulire dans le langage Pascal. les caractres accentus.
Le premier caractre d'un identificateur doit tre une lettre ou le caractre soulign _ . La taille minimum est de un caractre. Le langage Pascal ne fait pas de diffrence entre minuscules et majuscules. Un identificateur ne peut tre un mot-cl du langage. S'il n'y a aucune limite thorique au nombre de caractres composant un identificateur, tous les compilateurs imposent cependant un nombre maximal. Par exemple

Pascal Macintosh: 255, Pascal VAX: 31, Turbo Pascal: seuls les 63 premiers caractres d'un identificateur sont significatifs et sa longueur ne peut dpasser une ligne de l'diteur (127 caractres). .......
Rgles de bonne pratique Ces rgles de bonne pratique ne sont en aucun cas imposes par le langage Pascal. Ce sont simplement des conseils que l'exprience nous incite suivre.
Adoptez une convention. Il n'y a pas de convention qui soit meilleure qu'une autre. L'erreur est de ne pas en avoir. On se perd trs rapidement dans un code qui n'a pas de convention. Le caractre soulign est gnralement utilis dans le but d'amliorer la lisibilit. vitez des noms trop longs, ils deviennent peu lisibles: n'utilisez pas
nomdeleleveinscritalecole mais plutt nom_de_l_eleve_inscrit_a_l_ecole si vous tenez tre vraiment explicite ou plutt nom_eleve ou NomEleve . calculdelimpotdespersonnesphysiquesexercice2008revenus2007 X4p23wzq78bg977_q286 mois que cela ne reprsente quelque chose de prcis pour vous. X1 , X2 , X3 ,......, X99 lorsque vous devez dclarer plusieurs variables: que reprsente X37 ?
Adoptez un significatif de ce que l'identificateur reprsente: vitez
Lorsque vous dclarez une variable, n'hsitez pas mettre un commentaire pour expliciter ce qu'elle reprsente.
2 -6 Rv. 443
D.VIESLET
Exercice 1 Correct ou pas ? Quels sont les identificateurs corrects ou incorrects ? A A1 1b n ni racinecarree racinecarre Racine-carre Taxesurlavaleurajoutee Nombre 1 Longueur
2.4.4 Les identificateurs prdfinis

Les identificateurs prdfinis sont des mots possdant une signification par dfaut: INTEGER, READ , WRITELN,..... Il s'agit de types de variables, de fonctions, de procdure prdfinies,... Ils peuvent tre utiliss comme identificateur par le programmeur et donc redfinis, mais cela prte confusion. Il est donc possible d'appeler une variable INTEGER mais c'est viter! Exemples:

Types standard: INTEGER REAL BYTE Procdures standard: WRITE READLN RESET Fonctions standard: SIN ORD CHR ROUND EOF EOLN
ABS ARCTAN EOLN EXP FALSE GET INPUT INTEGER LN MAXINT NEW ODD ORD OUTPUT PACK PAGE PRED PUT READ READLN REAL RESET REWRITE ROUND SIN SQR SQRT SUCC TEXT TRUE TRUNC UNPACK WRITE WRITELN
En voici une liste alphabtique
BOOLEAN CHAR CHR COS DISPOSE EOF
Remarque: chaque version de Pascal possde des identificateurs prdfinis supplmentaires!
D.VIESLET
2 -7 Rv. 443
2.4.5 Les mots-cl

Les mots-cl sont des mots rservs par le langage Pascal. Ils constituent le vocabulaire de ce langage. Leur rle et leur signification sont parfaitement dfinis. En voici une liste alphabtique non exhaustive. On reconnat dans cette liste ceux dj cits jusqu' prsent (PROGRAM , CONST, VAR, BEGIN, END,....)
AND ARRAY BEGIN CASE CONST DIV DO DOWNTO ELSE END EXTERNAL FILE FOR FORWARD FUNCTION GOTO IF IN LABEL MOD NIL NOT OF OR PACKED PROCEDURE PROGRAM RECORD REPEAT SET STRING THEN TO TYPE UNTIL VAR
A ces mots-cl du langage Pascal standard, s'ajoutent ceux prvus par le compilateur (Turbo Pascal Version 4, Turbo Pascal Version 7, Dev Pascal, Delphi, Free Pascal, Kxylix, ...). Ces derniers peuvent tre diffrents d'un compilateur l'autre. En Turbo Pascal, on trouve
ABSOLUTE ASM ASSEMBLER CONSTRUCTOR DESTRUCTOR EXPORTS FAR IMPLEMENTATION INHERITED INLINE INTERFACE INTERRUPT LIBRARY NEAR OBJECT PRIVATE SHL SHR UNIT USES VIRTUAL XOR
En Pascal Macintosh
OTHERWISE USES
En Pascal VAX
MODULE OTHERWISE REM VALUE VARYING %DESCR %DICTIONNARY %INCLUDE %IMMED %REF %STDESCR
Le langage Pascal ne fait pas de diffrence entre les majuscules et minuscules. On peut indiffremment crire program , PROGRAM , Program , PrOgRaM ,....
2.4.6 Les symboles

Les symboles sont forms
2 -8 Rv. 443
D.VIESLET
d'un unique caractre spcial repris dans la liste du paragraphe 2.4.2 Le jeu de caractres Pascal de deux caractres spciaux accols. := affection .. intervalle (de......) <= infrieur ou gal (plus petit ou gal ) <> diffrent de >= suprieur ou gal (plus grand ou gal ) (* dbut commentaire *) fin de commentaire
2.4.7 Les constantes
Les constantes numriques (entires ou relles). Exemples:

1 +123 -36 12.3 -25.4 124e3
Valeur entire positive Valeur entire positive (le signe + est optionnel) Valeur entire ngative Valeur relle positive Valeur relle ngative Valeur relle positive exprime sous forme mantisse exposant (124 103 ou 124000)
-234.0e2 Valeur relle ngative exprime sous forme mantisse exposant (234 102 ou -23400) -0.3e-2 Valeur relle ngative (-0.3 10-2 ou -0.003)
Les constantes caractres, c'est--dire un caractre entre apostrophes. Exemples:

'a' '?' 'X'
les constantes chanes de caractres, c'est--dire une suite de plusieurs caractres entre apostrophes. Exemples:

'Bonjour tout le monde' 'CARRE' 'Jules Dupont' '###.##' 'Espce de @$&'
D.VIESLET
2 -9 Rv. 443
2.4.8 Les commentaires

Un commentaire est un texte libre que le programmeur insre dans le code source de manire apporter des informations complmentaires sur la signification du code. Les commentaires sont introduits dans un programme dans un but de clart. Ils doivent amliorer la lisibilit et la comprhension du code source du programme. Il faut les utiliser au maximum. Les commentaires sont ignors par le compilateur c'est dire que ce dernier ne gnre aucun code machine pour eux. Ils peuvent tre placs partout o un espace ou un saut de ligne est permis. Les commentaires, signals au compilateur par les symboles accolade ouvrante { : dbut de commentaire et accolade fermante } : fin de commentaire. Exemple:
{ un exemple de commentaire } Program ImpotPP2008; { Ce programme calcule l'impt des personnes physiques pour l'exercice 2008 c'est dire pour les revenus 2007 }
Cela vite de devoir appeler le programme

Program calculdelimpotdespersonnesphysiquesexercice2008revenus2007;
Rappelez-vous !!! Les parenthses associes avec un astrisque peuvent galement tre utilises. (* : dbut de commentaire et *) : fin de commentaire. Exemple:
(* Programme crit par: John Doe *)
Certains compilateurs ajoutent galement un troisime type de commentaire issu du langage C: le texte se trouvant aprs une double barre oblique // est considre comme un commentaire. Dans ce cas, le commentaire ne peut s'tendre que sur une ligne et ne possde qu'une marque de dbut:
//ceci est un commentaire
Il est indispensable de commenter ses programmes. Il est erron de penser que les codes sources sont lisibles et comprhensibles, mme pour celui qui l'encode. Il faut garder l'esprit que les programmes sont susceptibles d'tre modifis longtemps aprs leur encodage, et les commentaires sont indispensables dans ce cas. Dans la plupart des cas, les commentaires sont destins l'auteur du programme. Mais dans tous les cas o un programme est ralis en quipe ou repris par d'autres personnes que l'auteur, les commentaires doivent tre une aide la comprhension, surtout dans certains passages peu vidents. Il n'est pas rare de rencontrer des programmes o les commentaires occupent plus de place que les instructions ellesmmes. Il ne faut cependant pas oublier de mettre jour les commentaires lors de la modification de tout ou partie du programme. Un commentaire devenu caduc ou qui n'a pas t mis jour perd son utilit et peut mme devenir un obstacle la comprhension d'un programme.
2 -10 Rv. 443
D.VIESLET
2.4.9 Rgles gnrales du langage Pascal

Un espace, une tabulation ou un saut de ligne est obligatoire pour sparer les diffrentes units lexicales, sauf lorsqu'elles sont spares par : ou ; . La mise en page est libre, c'est--dire que les instructions peuvent tre mises la suite les unes des autres sur la mme ligne ou sur des lignes diffrentes. Toutefois, pour une question de lisibilit du code, il est prfrable de les disposer sur des lignes diffrentes. Par ailleurs, une chane de caractres ne peut tre crite sur plusieurs lignes. Une ligne ne peut contenir que 126 caractres. Un programme principal dbute toujours par BEGIN et se termine par END. (avec un point). Alors qu'un sous-programme (ou fonction, procdure, bloc conditionnel...) commence lui aussi par BEGIN mais se termine par END; (avec un point-virgule). Chaque commande doit se terminer avec un point-virgule. Il y a toutefois des exceptions cette rgle:

l'instruction BEGIN ne prend pas de point-virgule, l'instruction prcdant le ELSE dans une structure conditionnelle IF ... THEN ... ELSE ne prend pas de point-virgule, Pour l'instruction prcdant le ELSE dans une structure conditionnelle CASE ... OF ... ELSE , le point-virgule est facultatif, pour l'instruction prcdant un END, la point-virgule est facultatif.
D.VIESLET
2 -11 Rv. 443
3 Les variables: premire partie

3.1 Introduction
Les variables permettent de stocker des valeurs et de l'information. Elles permettent en outre aux programmes d'effectuer des calculs et de stocker les rsultats obtenus afin de les reprendre par aprs. Elles peuvent contenir des nombres, des noms, du texte, des messages, etc. Les variables sont stockes dans la mmoire vive de l'ordinateur.
3.2 Dclaration
Toutes les variables doivent tres pralablement dclares avant d'tre utilises dans le programme, c'est--dire qu'on leur affecte un type. On peut les dclarer de diverses manires:
Au tout dbut du programme dans la section VAR avec la syntaxe

Var nom_de_la_variable: Type;
elles seront alors valables pour le programme dans son intgralit (sousprogrammes, fonctions, procdures...). Ces variables sont appeles globales. Bien que leur utilisation soit dconseille dans des programmes consquents, nous les utiliserons dans un premier temps pour une question de facilit.
Au dbut d'une procdure avec la syntaxe prcdente. Elles ne seront valables que dans la procdure. Aprs la dclaration des procdures, toujours avec la mme syntaxe, elles ne pourront alors pas tres utilise par les procdures qui devront donc tre paramtres (voir procdures paramtres).
Var NomVar1, NomVar2, NomVar3: Type;
Plusieurs variables peuvent tre dfinies en mme temps: Ce code dclare trois variables appeles NomVar1, NomVar2 et NomVar3 de type appel type . Si elles sont de types diffrents, on utilise la syntaxe:
Var NomVar1, NomVar2: Type1; NomVar3: Type2; NomVar4: Type3;
Ce code dclare deux variables appeles NomVar1 et NomVar2 de type type1 , une appele NomVar3 de type type2 et une NomVar4 de type type3 . Pour faire la mme chose, on aurait pu crire:
Var NomVar1, NomVar2: Type1; NomVar3: Type2; NomVar4: Type3;
Bien que le fonctionnement de ce code est rigoureusement identique, il est plus lisible. Les noms de variables sont des identificateurs que le programmeur choisit. Reportez-vous au point 2.4.3 Les identificateurs pour les remarques concernant ce choix et les rgles d'criture.
3.3 Les types de variables

Parmi les avantages qu'offre le langage Pascal, on trouve une grande richesse de types de donnes. La notion de type est trs importante puisqu'elle dtermine la nature et l'ensemble des valeurs que peut prendre une variable. Selon leur contenu, D.VIESLET Principes et mthodes de programmation Les variables: premire partie 3 -1 Rv. 443
on distinguera par exemple celles devant contenir une valeur numrique (longueur, nombre d'lves, quantit,...) de celles devant contenir du texte (nom, adresse,...). Parmi les numriques, on distinguera celles devant contenir des nombres entiers: pas de partie dcimale (nombre d'lves) de celles devant contenir un nombre rel (longueur, quantit). Le Pascal classifie les variables en deux types principaux: simples et structurs. Qui se subdivisent comme suit:
Types simples

Type entier Type caractre Type boolen Type numr Type intervalle Type rel Type tableau Type chane de caractres Type ensemble Type enregistrement Type fichier
Types structurs

On appelle type simple tout ensemble d'lments ordonns Exemple: 1<2<3<4 Si cet ensemble est fini, on dit que le type est un type scalaire. Si cet ensemble n'est pas fini on dit qu'il est de type rel. Nous pouvons donc diviser les types simples en deux catgories: Les types scalaires: ensemble d'lments ordonns et finis; les types rels: ensemble d'lments ordonns mais non fini.
Types scalaires

Type entier Type caractre Type boolen Type numr Type intervalle Type rel
Type rel
En ce qui concerne les types simples, on les regroupe en type standard ou prdfini et type dfinis: 3 -2 Rv. 443 Principes et mthodes de programmation Les variables: premire partie D.VIESLET
Types standard

Type entier Type caractre Type boolen Type rel Type numr Type intervalle
Types dfinis

On peut schmatiser cette classification comme suit:
Types simples
Types standards
Types scalaires Entier Enumr Caractre Intervalle Boolen
Rel
Types structurs Tableau Chane Ensemble
Enregistrement
Fichier
D.VIESLET
Principes et mthodes de programmation Les variables: premire partie
3 -3 Rv. 443
3.4 Prise de valeurs ou affectation

La valeur des variables doit pouvoir tre modifie en cours de droulement du programme. Une des faons de procder est d'utiliser l'oprateur d'affectation := (le symbole deux points suivi du signe gal). L'affectation (ou assignation) est l'une des instructions les plus importantes en Pascal. Elle permet de placer une valeur, qui est le rsultat de l'valuation d'une expression, dans une position mmoire rfrence par une variable: Dclaration:
variable := expression;
O variable est l'identificateur d'une variable qui a t dclare auparavant. L'expression peut tre une simple variable, simple constante ou une combinaison de constantes, variables et oprateurs arithmtiques. Par exemple
Nombre := 3; Annee := 2007; Car := 'a';
Il est impratif que le type de l'expression soit compatible avec le type de la variable laquelle on affecte le rsultat de l'expression. On peut galement utiliser une opration mathmatique faisant ventuellement appel des fonctions. Nous reviendrons sur ce point dans la suite.
3.5 Les types simples

3.5.1 Le type entier
Il existe 6 types d'entiers qui se diffrencient par l'intervalle de valeurs qu'ils peuvent prendre et et le nombre d'octets qu'ils occupent en mmoire (Taille). Le tableau suivant rsume ces diffrentes caractristiques: Type d'entiers Identificateur Entiers courts Entiers petits Entiers Entiers longs Octets Mots Cardinaux Shortint Smallint Integer Longint Byte Word Cardinal Taille Intervalle 1 2 4 1 2 4 [-128 .. +127] [-32768 .. +32767] [ -2147483648 .. +2147483647] [0 .. +255] [0 .. +65535] [0 .. +4294967295] Format Sign Sign Sign Sign Non sign Non sign Non sign
4 (*) [ -2147483648 .. +2147483647]
(*) Il convient de signaler que les type SMALLINT et LONGINT sont indpendants de la plate-forme, alors que les types INTEGER et CARDINAL sont stocks sur 2 octets avec des compilateurs prvus pour des systmes d'exploitation 16 bits (Exemple Turbo Pascal prvu pour DOS et Windows 3.x ou Pascal Macintosh prvu pour MAC OS) et sur 4 octets avec des compilateurs prvus pour des systmes d'exploitation 32 bits (Exemple: Delphi, Dev Pascal prvus pour
3 -4 Rv. 443
D.VIESLET
Windows 95, 98 , 2000, NT, XP ,Xilix prvu pour Linux, Pascal VAX prvu pour VMS). Pour dterminer si le compilateur code les entiers sur 2 ou 4 octets, il fait utiliser la constante prdfinie MAXINT qui donnera la valeur maximale que peut prendre l'entier. Ainsi, pour Pascal Macintosh MAXINT vaut 32767 (c--d 2 15 1) et pour Pascal VAX MAXINT vaut 2147483647 (c--d 2 31 - 1). Dclaration de variables entires:
Var id1, id2, id3, ...idn: idtype;

id1, id2, ... sont les identificateurs (noms) des variables. idtype est le type de variable: SHORTINT, SMALLINT, INTEGER, LONGINT, BYTE, WORD ou CARDINAL.
3.5.2 Le type boolen

Le type boolen est galement appel type logique et est dfini par deux constantes: FALSE et TRUE (FAUX et VRAI). Elles expriment les seules valeurs que peuvent recevoir une constante ou une variable boolenne. Dclaration de variables boolennes:
Var id1, id2, ...idn: Boolean;

id1, id2, ... sont les identificateurs (noms) des variables. BOOLEAN est le type de variable.
3.5.3 Le type caractre

Le type caractre comprend tous les caractres disponibles dans la table ASCII. Il est cod sur un octet. Dclaration d'un type caractre:
Var id1, id2, ...idn: Char;

id1, id2, ... sont les identificateurs (noms) des variables. CHAR est le type de variable.
La table ASCII (American Standart Code for Information Interchange) est un tableau de 256 caractres numrots de 0 255 o les 31 premiers sont des caractres de commande non imprimables associs des fonction de base (tabulation, retour chariot, saut de ligne, saut de page,.....) et tous les autres sont directement affichables (lettres, chiffres, ponctuations, symboles, caractres graphiques). Les 127 premiers caractres forment le code ASCII de base mis au point pour la langue anglaise. Il ne contient donc pas de caractres accentus, ni de caractres spcifiques une langue. Pour coder ce type de caractre il faut recourir un autre code. Le code ASCII a donc t tendu 8 bits (un octet) pour pouvoir coder plus de caractres. Le code ASCII tendu n'est pas unique; les 128 derniers caractres peuvent varier en fonction de la langue utilise. Dans un programme en Pascal, on peut travailler sur un caractre partir de son numro dans la table ASCII en utilisant le symbole dise # ou directement avec sa valeur affichage entre apostrophes ' . Exemples:
lettre := 'P'; lettre := #80;
D.VIESLET
3 -5 Rv. 443
La table ASCII
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 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
e A B C D E F G H I J K L N N 0 P Q R S T U U U X Y Z [ \ ] ^ _
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
` a b c d e f g h i j k l m n o p q r s t u y u v w z { | } ~
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 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 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
/ 0 1 2 3 4 5 6 7 8 9 : ; < = > ?
3 -6 Rv. 443
D.VIESLET
3.5.4 Le type rel

Les diffrents types rels se diffrencient par leur domaine de dfinition (Bornes), le nombre de chiffres significatifs (Prcision) et le nombre d'octets qu'ils occupent en mmoire (Taille). Le tableau suivant rsume ces diffrentes caractristiques: Type de rels Rels Rels Rels simples Rels doubles Rels tendus Identificateur Taille Bornes Real48 Real Single Double Extended 6(*) 8 4 8 10 8 2.9 10-039 et 1.7 10+038 5.0 10-324 et 1.7 10+308 1.5 10-045 et 3.4 10+038 5.0 10-324 et 1.7 10+308 1.9 10-4951 et 1.1 10+4932 9.2 10 -018 et 9.210 +018 Prcision 11 12 15 16 7 8 15 16 19 20 19 20
Rels compatibles Comp
(*) Le type Real48 sur six octets s'appelait Real dans les versions prcdentes du Pascal Objet. Real48 est conserv pour la compatibilit ascendante. Comme son format de stockage n'est pas gr naturellement par l'architecture des processeurs Intel, ce type produit des performances plus mauvaises que les autres types virgule flottante. Extended propose une meilleure prcision que les autres types rels, mais il est moins portable. Evitez d'utiliser Extended si vous crez des fichiers de donnes qui doivent tre partags sur plusieurs plates-formes. Le type Comp est un type natif de l'architecture des processeurs Intel et reprsente un entier sur 64 bits. Il est nanmoins class parmi les rels car il ne se comporte pas comme un type scalaire. Par exemple, il n'est pas possible d'incrmenter ou de dcrmenter une valeur Comp. Comp est conserv uniquement pour la compatibilit ascendante. Utilisez le type Int64 pour de meilleures performances. Dclaration d'un type rel:
Var id1, id2, id3, . . . idn: idtype;

d1,id2,... sont les identificateurs (noms) des variables. idtype est le type de variable: REAL , SINGLE, DOUBLE, EXTENDED ou COMP.
12.43 -0.453 +1.0 1 - 3.5 4.25E+4 4.25E4 5.48E-3 -45e-13 5e0.2 -.25e3 4.e10 OK OK OK NOK (pas de point dcimal -> entier) NOK (espace entre le signe et le nombre) OK OK OK OK NOK NOK NOK
Il peut s'crire sous la forme dcimale. Exemples:
Ou sous forme exponentielle. Exemples:
(exposant non entier) (pas de chiffre avant le point) (pas de chiffre entre le point et e)
D.VIESLET
3 -7 Rv. 443
3.6 Les types structurs

3.6.1 Le type chane de caractres
Une chane de caractres est compose d'une squence de caractres. Ceux-ci appartiennent la table ASCII. Leur nombre est compris entre 1 et 255 (par dfaut) Dclaration d'une chane de caractres
Var id1, id2, ...idn: String[n];

id1, id2 sont les noms des variables. n est le nombre de caractres de la chane. Il doit tre compris entre 1 et 255. Si [n] est omis, la chane contiendra 255.
Lors de l'affectation d'une valeur une chane de caractres, celle-ci sera sera tronque la taille maximum de la chane si elle l'excde. La valeur affecte doit tre entoure d'apostrophes ' : symbole de dbut et fin de chane. Si une apostrophe fait partie de la chane de caractres, elle doit tre double. Exemple:
'l''abeille'
Si la valeur de l'affectation est suprieure la longueur autorise de la variable chane, elle sera simplement tronque sur la droite:
Program prgString_2; Var s1: String; s2: String[12]; Begin s1 := 'CHAINE DE LONGUEUR SUPERIEURE A 12'; s2 := s1; Writeln('Ma premire chane vaut: ', s1); Writeln('Ma deuxime chane vaut: ', s2); End.
Exercice 2 Ma premire chane Encodez le programme donn en exemple ci-dessus. Compilez et excutez. Voyez la diffrence entre les deux lignes. Modifiez le programme de manire affecter aujourd'hui la variable S1 . Compilez et excutez.
3 -8 Rv. 443
D.VIESLET
4 Les entres sorties conversationnelles

Les entres sorties conversationnelles sont des instructions qui permettent l'utilisateur de dialoguer avec le programme. Deux commandes permettent au programme d'crire du texte l'cran: WRITE et WRITELN et deux autres lui permettent de lire le texte que l'utilisateur tape au clavier: READ et READLN. On trouve galement une troisime instruction permettent de lire un seul caractre: READKEY
4.1 WRITE et WRITELN

La commande WRITE permet d'afficher du texte l'cran et de laisser le curseur la fin de la ligne. Le texte doit tre donn en paramtre et plac entre apostrophes.
Program Bonjour; Begin Write('Bonjour'); End.
Voici un programme tout simple qui se contente d'crire Bonjour l'cran. Pour faire revenir le curseur la ligne, on utilise la commande WRITELN.
Program Bonjour; Begin Writeln('Bonjour'); Writeln('Tout le monde'); End.
Ce programme affiche deux lignes et place le curseur au dbut de la ligne suivante. Le texte doit tre plac entre apostrophes. Si ce texte contient lui-mme une apostrophe, elle doit tre double.
Program afficheapostrophe; Begin Writeln('Comment afficher l''apostrophe ?'); End. Program Bonjour; Begin Writeln('Bonjour'); Writeln('Aujourd''hui il fait beau'); End.
Ces instructions peuvent accepter plusieurs paramtres qui sont des variables. Dans ce cas, la valeur de la variable sera affiche l'cran.
D.VIESLET
Principes et mthodes de programmation Les entres sorties conversationnelles
4 -1 Rv. 443
Program Bonjour; Var i: Integer; { dclaration de la variable i } Begin Writeln('Bonjour'); { affichage d'un premier message } i := 2; { affectation de la valeur 2 la variable i } Writeln('Ma variable i vaut: ', i); i := 3; { affectation de la valeur 3 la variable i } Writeln('Ma variable i vaut maintenant: ', i); End.
On aurait galement pu crire:

Program Bonjour; Var i: Integer; Begin Writeln('Bonjour'); i := 2; Write('Ma variable i vaut: '); Writeln(i); i := 3; Write('Ma variable i vaut maintenant: '); Writeln(i); End.
Le fonctionnement est identique. L'affichage d'une variable, d'une constante ou d'une expression l'cran prend un certain nombre de caractres. Ce nombre est dtermin par dfaut en fonction de son type et de sa valeur. Nature de l'expression Nombre de caractres utiliss par dfaut STRING Sa propre longueur INTEGER Le minimum ncessaire son affichage, compte tenu de sa valeur effective augment ventuellement de un si il est ngatif REAL 12 ou 17 selon les compilateurs CHAR 1 BOOLEAN 4 (true) ou 5 (false)
4 -2 Rv. 443
D.VIESLET
Exemple:
Program FormatDefaut; Var n, p: Integer; x, y: Real; c1, c2: Char; ok: Boolean; Begin n := 3; p := 125; x := 3450000.0; y := 2.0; c1 := 'e'; c2 := 'i'; ok := false; Writeln('nombre', n); Writeln('nombre ', n); Writeln(n, p); Writeln(n,' ',p); Writeln(C1, C2); Writeln(x, y); Writeln('cela est ', ok); End.
Ce programme affichera Instruction

Writeln('Nombre', n); Writeln('Nombre ', n); Writeln(n, p); Writeln(n,' ', p); Writeln(C1, C2); Writeln(x, y); Writeln('cela est ',ok);
Affichage Nombre3 Nombre 3 3125 3 125 ei 3.4500000000E+06 2.0000000000E+00 cela est FALSE
Il est possible de modifier ce gabarit d'affichage par dfaut, c'est--dire le nombre de caractres que chaque variable va occuper l'cran. Il suffit de faire suivre le nom de la variable du symbole deux-points : et d'un entier reprsentant le nombre de caractres. Lorsque le gabarit dfini par l'utilisateur est trop petit pour afficher la variable complte, Pascal outrepasse celui-ci et impose un gabarit minimum qui correspond aux valeurs par dfaut. Pour des variables relles, il est possible de prciser galement le nombre de dcimales en ajoutant nouveau la symbole deuxpoints suivi du nombre de dcimales. Dans ce cas, la premire valeur reprsente le nombre total de caractres ncessaire l'affichage du rel et la seconde le nombre de dcimales. Le point dcimal . et l'ventuel signe ngatif - comptent pour un caractre.
D.VIESLET
4 -3 Rv. 443
Exemple:
Program FormatDefini; Var n, p: Integer; x: Real; c1, c2: Char; ok: Boolean; Begin n := 3; p := 125; x := 1.23456e2; c1 := 'e'; c2 := 'i'; ok := false; Writeln('nombre ', n:4); Writeln(n:3, p:5); Writeln(c1:3, c2:6, ok:7); Writeln(p:2); Writeln('bonjour':3, ok:2); Writeln(x:20); Writeln(x:10); Writeln(x:2); Writeln(x:12:4); Writeln(x:10:1); Writeln(x:8:5); End.
Ce programme affichera Instruction

Writeln('Nombre', n:4); Writeln(n:3, p:5); Writeln(c1:3, c2:6, ok:7); Writeln(p:2); Writeln('bonjour':3, ok:2); Writeln(x:20); Writeln(x:10); Writeln(x:2); Writeln(x:12:4); Writeln(x:10:1); Writeln(x:8:5);
Affichage Nombre 3 3 125 e 125 bonjourFALSE 1.23456000000E+02 1.2346E+02 1.2E+02 123.4560 123.5 123.45600 i FALSE
4 -4 Rv. 443
D.VIESLET
Le gabarit peut tre impos par des variables de type entier. Exemple:
Program FormatDefiniVariable; Var Pos,Dec: Integer; x: Real; Begin Write('Nombre total de chiffres: '); Readln(Pos); Write('Nombre de dcimales : '); Readln(Dec); Write('Donnez le rayon d''un cercle: '); Readln(x); Writeln('Le diamtre vaut: ',2*x*3.1425927:Pos:Dec); End.
4.2 READ et READLN

La commande READ permet l'utilisateur de donner une valeur qui sera utilise par le programme. Cette commande ne provoque pas de retour chariot, c'est--dire que le curseur ne passe pas la ligne. Syntaxe:
Read(variable);
Pour introduire plusieurs variables, il faut utiliser la syntaxe suivante:

Read(variable1, variable2, ...);
Les diffrentes valeurs doivent tre spares par un caractre d'espacement. La commande READLN provoque le retour Chariot, c'est--dire que le curseur passe la ligne suivante. Lorsqu'aucune variable n'est affecte la commande, il suffit de presser sur la touche ENTREE . Syntaxe:
Readln(variable1, variable2, ...);
Ou pour attendre que l'utilisateur appuie sur la touche ENTREE

Readln;
Exemples d'utilisation:
Program PrgInOut0; Var nom: String; Begin Write('Entrez votre nom: '); Readln(nom); Writeln('Votre nom est ', nom); Readln; End.
D.VIESLET
4 -5 Rv. 443
Ce programme exemple1 dclare tout d'abord la variable nomme nom comme tant une chane de caractre (STRING). Ensuite, dans le bloc programme principal, il est demand l'utilisateur d'affecter une valeur la variable nom qui est initialise automatiquement (valeur nulle) chaque dmarrage du programme. Ensuite, il y a affichage de la valeur de la variable et attente que la touche entre soit valide (le dernier READLN). Lecture d'un entier:
Program prgInOutl; Var n: Integer; Begin Write('Donnez un entier'); Readln(n); Writeln('Merci pour ', n); End.
Pour la lecture de deux entiers:

Program prgInOut2; Var n, p: Integer; Begin Writeln('Donnez deux entiers'); Readln(n, p); Writeln('Merci pour ', n, ' et ', p); End.
Pour la lecture d'un rel:

Program prgInOut3; Var x: Real; Begin Writeln('Donnez un nombre rel'); Readln(x); Writeln('Merci pour ', x); End.
Pour la lecture d'un caractre:

Program prgInOut4; Var c1: Char; Begin Writeln('Donnez un caractre'); Readln(c1); Writeln('Merci pour ', c1); End.
4 -6 Rv. 443
D.VIESLET
Lecture de deux caractres:

Program prgInOut5; Var c1, c2: Char; Begin Writeln('Donnez deux caractres'); Readln(c1, c2); Writeln('Merci pour ', c1, ' et ', c2); End.
Lecture d'un caractre et d'un entier:

Program prglnOut6; Var c1: Char; n: Integer; Begin Writeln('Donnez un caractre et un nombre'); Readln(c1, n); Writeln('Merci pour ', c1, ' et ', n); End.
Lecture d'un entier et de deux caractres:

Program prgInOut8; Var c1, c2: Char; n: Integer; Begin Writeln('Donnez un nombre et deux caractres'); Readln(n, c1, c2); Writeln('Merci pour ', n, ' et ',c1 , ' ', c2); End.
Exercice 3 Comment vous appelez-vous ? Ecrivez un programme qui demande l'utilisateur son nom et son prnom. Stockez ces valeurs dans deux variables de type chane de caractres. Affichez ensuite le message Bonjour suivi du prnom et du nom. Pour la lecture, utilisez la fonction

READLN en passant deux paramtres deux fois la fonction READLN en passant chaque fois un paramtre
D.VIESLET
4 -7 Rv. 443
5 Les oprateurs
Les oprateurs sont utiliss pour manipuler les donnes. Ils effectuent des oprations arithmtiques, des vrification dgalit, manipulent des variables. Nous donnerons ici une liste des plus courants.
5.1 Oprateur daffectation

Cet oprateur permet daffecter une valeur une variable pralablement dclare. Cette valeur peut tre une constante, une autre variable ou le rsultat dun calcul sur des variables et/ou des constantes. Oprateur := Exemple:
Program affectation; Var nombre: Integer; lettre: Char; montant: Real; Begin nombre := 34; {ceci stocke la valeur 34 dans nombre1} lettre := 'z'; {ceci stocke le caractre z dans lettre} montant := 23.14;{ceci stocke la valeur 23.14 dans montant} End.
Opration Affectation
Exemple X := 10
Mauvais exemples:
Program affectation; Var nombre: Integer; lettre: Char; montant: Real; Begin nombre := 34.12;{La variable nombre1 est un entier. Il ne peur donc y avoir de partie dcimale} lettre := 'zzz'; {La variable lettre ne peur contenir qu'un seul caractre} montant := .14; {Pour un rel, il faut toujours prciser la partie entire mme si elle est nulle montant:=0.14 est correct} End.
Avec affichage des variables:
D.VIESLET
Principes et mthodes de programmation Les oprateurs
5 -1 Rv. 443
Program AfficheVariables; Var nombre: Integer; lettre: Char; montant: Real; Begin nombre := 23; lettre := 'W'; montant := 23.73; Writeln('nombre= ', nombre); Writeln('lettre = ', lettre ); Writeln('montant = ', montant ); End.
5.2 Oprateurs arithmtiques

Les oprateurs arithmtiques suivants attendent des oprandes de type rel ou entier: +, , *, /, DIV et MOD. Oprateur + * / DIV MOD Opration Addition Soustraction Multiplication Division relle Division entire Types d'oprande Entier, Rel Entier, Rel Entier, Rel Rel Entier Type du rsultat Entier, Rel Entier, Rel Entier, Rel Rel Entier Entier Exemple X+Y Resultat - 1 P * TauxTVA X/2 Total Div Nombre Y MOD 6
Reste de division ent. Entier
Program ArithmReel; Var nombrel, nombre2, resultat: Real; Begin nombrel := 15.3; nombre2 := 2.0; { Addition } resultat := nombrel + nombre2; Writeln(nombrel,' + ', nombre2,' gal ', resultat); { Soustraction } resultat := nombrel - nombre2; Writeln(nombrel,' - ', nombre2,' gal ', resultat); { Multiplication } resultat := nombrel * nombre2; Writeln(nombrel,' * ', nombre2,' gal ', resultat); { Division } resultat := nombrel / nombre2; Writeln(nombrel,' / ', nombre2,' gal ', resultat); End.
5 -2 Rv. 443
D.VIESLET
Program ArithmEntier; Var nombrel, nombre2: Integer; Begin nombrel := 15; nombre2 := 2; { Addition } Writeln(nombrel,' + ', nombre2,' gal ', nombrel + nombre2); { Soustraction } Writeln(nombrel,' - ', nombre2,' gal ', nombrel - nombre2); { Multiplication } Writeln(nombrel,' * ', nombre2,' gal ', nombrel * nombre2); { Division } Writeln(nombrel,' Div ', nombre2,' gal ', nombrel Div nombre2); { Modulo } Writeln(nombrel,' Mod ', nombre2,' gal ', nombrel Mod nombre2); End. Program PrgAttention; Const x = 1e37; y = 1.0; Var valeur1, valeur2: Real; Begin valeur1 := x + y - x; valeur2 := x - x + y; Writeln('Valeur 1: ', valeur1); Writeln('Valeur 2: ', valeur2); End.
Conversions de types Il est possible d'crire des expressions formes d'oprandes entires et relles ainsi que d'oprateurs sur ces deux types. Une telle expression est appele expression mixte. Son valuation se fait conformment aux rgles de priorits en prcisant que dans une (sous-)expression comportant un oprateur rel, les ventuelles oprandes entires sont converties en oprandes relles puis le calcul est effectu. Exemples: 2.0 * 5 3 - 2.0 3/2 mais: (10 div 5) / 2 la conversion n'a lieu qu'aprs le calcul de 10 div 5 D'autre part il est possible d'crire
variable_relle := expression_entire;
5 est converti en 5.0 3 est converti en 3.0 3 et 2 sont convertis en 3.0 et 2.0
D.VIESLET
5 -3 Rv. 443
C'est un cas ou l'affectation porte sur des objets de types diffrents. L'expression entire est d'abord calcule puis sa valeur est convertie en la valeur relle correspondante et affecte la variable relle. Oprateur + (unaire) (unaire) Opration Signe identit Signe ngation Types d'oprande Entier, Rel Entier, Rel Type du rsultat Entier, Rel Entier, Rel Exemple +7 -X
5.3 Oprateurs logiques

Les oprateurs logiques suivants effectuent des manipulations bit--bit sur des oprandes entiers. Si, par exemple, la valeur stocke dans X est (au format binaire) 001101 et si la valeur stocke dans Y est 100001, l'instruction
Z := X Or Y;
affecte la valeur 101101 Z. Oprateur NOT AND OR XOR SHL SHR Opration Ngation Et Ou Ou exclusif Dcalage gauche Dcalage droite Types d'oprande Entier Entier Entier Entier Entier Entier Type du rsultat Entier Entier Entier Entier Entier Entier Exemples NOT X X AND Y X OR Y X XOR Y X SHL 2 Y SHR I
5.4 Oprateurs de comparaison

Les oprateurs de comparaison sont utiliss pour comparer deux oprandes. Les oprateurs = , <> , <= et >= s'appliquent galement aux ensembles (voir Oprateurs d'ensembles); = et <> s'appliquent galement aux pointeurs (voir Oprateurs de pointeurs). Oprateur = Opration Egalit Types d'oprande Scalaires, rels, chanes de caractres, pointeurs, ensembles Scalaires, rel, chanes de caractres, pointeur, ensembles Scalaires, rel, chanes de caractres Scalaires, rel, chanes de Type du rsultat Boolen Exemple I = Max
<>
Diffrence
Boolen
X <> Y
<
Infrieur
Boolen
X<Y
>
Suprieur
Boolen
Len > 0
5 -4 Rv. 443
D.VIESLET
caractres <= Infrieur ou gal Scalaires, rel, chanes de caractres, ensembles Scalaires, rel, chanes de caractres, ensembles Boolen Cnt <= I
>=
Suprieur ou gal
Boolen
I >= 1
Dans la plupart des cas simples, la comparaison est vidente. Par exemple I = J vaut TRUE uniquement si I et J ont la mme valeur, sinon I <> J vaut TRUE.
5.5 Oprateurs de chane de caractres

Les oprateurs relationnels = , <> , < , > , <= et >= acceptent tous des oprandes chane (voir Oprateurs relationnels). L'oprateur + concatne deux chanes. Le contenu de la deuxime chane de caractres sera ajoute la fin de la premire Oprateur + Exemple:
A := 'Bonjour'; B := ' le monde'; C := A + B;
Opration Concatnation
Types d'oprande Chane, Caractre
Type du rsultat Chane
Exemple S + '. '
donnera pour C: 'Bonjour le monde'

A := 'Bonjour'; B := 'le monde'; C := A + ' tout' +B;
donnera pour C: 'Bonjour tout le monde'
5.6 Oprateurs de pointeurs

En plus des oprateurs de comparaison = et <> , les oprateurs suivants acceptent galement des pointeurs comme oprandes. Oprateur + ^ Opration Addition Soustraction Drfrencement Types d'oprande pointeur de caractre, entier pointeur de caractre, entier pointeur Type du rsultat pointeur de caractre pointeur de caractre, entier type de base du pointeur Exemple P+I P-Q P^
D.VIESLET
5 -5 Rv. 443
L'oprateur ^ drfrence un pointeur. Son oprande peut tre un pointeur de type quelconque sauf un pointeur gnrique (Pointer). P = Q vaut TRUE si P et Q pointent sur la mme adresse; sinon, P <> Q est TRUE. Vous pouvez utiliser les oprateurs + et - pour incrmenter ou dcrmenter le dcalage d'un pointeur de caractre. Vous pouvez galement utiliser - pour calculer la diffrence de dcalage entre deux pointeurs de caractre.
5.7 Oprateurs boolens

Les oprateurs boolens NOT, AND, OR et XOR prennent des oprandes de tout type boolen et renvoie une valeur de type Boolen. Oprateur NOT AND OR XOR Opration Ngation Conjonction Disjonction Disjonction exclusive Types d'oprande Boolen Boolen Boolen Boolen Type du rsultat Boolen Boolen Boolen Boolen Exemple Not (C in MySet) OK And (T> 0) A Or B A Xor B
Ces oprations sont rgies par les rgles de l'algbre boolenne. Par exemple, une expression de la forme X AND Y vaut TRUE si et seulement si X et Y valent tous les deux TRUE.
5.8 Oprateurs d'ensembles

Oprateur = <> <= >= IN + * Opration Egalit Diffrence Inclusion Contenance Appartenance Union Intersection Diffrence Types d'oprande Ensemble Ensemble Ensemble Ensemble Ensemble Ensemble Ensemble Ensemble Type du rsultat Boolen Boolen Boolen Boolen Boolen Ensemble Ensemble Ensemble Exemple I=M X <> Y X <= Y X>=Y 'C' IN X
5.9 Oprateurs divers

Oprateur @ $ [] . Opration Adressage Valeur hexadcimale Indice de tableau Qualification Exemple P := @x X := $FF X := MonTableau[5] X := MonObjet.UneProprit
L'oprateur @ renvoie l'adresse d'une variable, d'une fonction, d'une procdure ou d'une mthode; @ construit un pointeur sur son oprande. 5 -6 Rv. 443 Principes et mthodes de programmation Les oprateurs D.VIESLET
5.10 Rgles de priorit

Dans des expressions complexes, les rgles de priorit dterminent l'ordre dans lequel les oprations sont effectues. Oprateurs @, NOT, - , + (unaire) *, /, DIV, MOD, AND, SHL, SHR +, -, OR, XOR =, <>, <, >, <=, >=, IN Priorit premire (maximum) seconde troisime quatrime (minimum)
Un oprateur de priorit plus leve est valu avant un oprateur de priorit plus basse, les oprateurs de mme priorit tant valus partir de la gauche. Ainsi l'expression:
X + Y * Z
multiplie Y par Z puis ajoute X au rsultat; la multiplication est value en premier car sa priorit est suprieure celle de l'addition. Mais
X - Y + Z
commence par soustraire Y X puis ajoute Z au rsultat: et + ayant la mme priorit, l'opration de gauche est effectue en premier. Vous pouvez utiliser des parenthses pour redfinir ces rgles de priorit. Une expression entre parenthses est tout d'abord value puis traite comme une seule oprande. Par exemple:
(X + Y) * Z
multiplie Z par la somme de X et Y. Les parenthses sont parfois ncessaires dans des situations o, au premier regard elles ne sembles pas utiles. Par exemple, soit l'expression:
X = Y Or X = Z
L'interprtation voulue est manifestement:

(X = Y) Or (X = Z)
Nanmoins, sans parenthses, le compilateur respecte les rgles de priorit des oprateurs et commence par faire l'opration OR entre Y et X. Il interprte donc cette expression comme:
(X = (Y Or X)) = Z
Ce qui provoque une erreur de compilation sauf si Z est un boolen. Les parenthses rendent souvent le code plus simple crire et lire mme quand elles sont, techniquement parlant, inutiles. Ainsi le premier exemple peut galement s'crire:
X + (Y * Z)
D.VIESLET
5 -7 Rv. 443
Ici les parenthses ne sont pas ncessaires pour le compilateur, mais elles pargnent au programmeur et au lecteur la ncessit de rflchir la priorit des oprateurs. En cas d'incertitude, il est toujours prfrable d'utiliser des parenthses pour tablir les priorits. Exercice 4 La priorit Evaluez les expressions suivantes: 4+2*7 4 + (2 * 7) (4 + 2) * 7 (4 + 2 * 7) 13 div 3 * 4 13 * 4 div 3 13 div (3 * 4) Exercice 5 Les parenthses inutiles Dans les expressions suivantes, dterminez quelles sont les parenthses facultatives 4+2*7 4 + (2 * 7) (4 + 2) * 7 (4 + 2 * 7) (13 div 3) * 4 (13 * 4) div 3 13 div (3 * 4) Exercice 6 Le prix total TVA Comprise Ecrivez un programme qui demande l'utilisateur le prix unitaire hors TVA, le taux de TVA et la quantit. Ce programme calcule et affiche le prix total TVA comprise. Exercice 7 Le prix total du stock Dans un entrept se trouvent des tables et des chaises. Une table vaut 120 et une chaise 50. Ecrivez un programme qui demande l'utilisateur le nombre de tables et de chaises. Ce programme calcule et affiche le prix total du mobilier de l'entrept. Exercice 8 Le prix de l'eau Ecrire un programme qui demande lutilisateur de saisir le prix en euro dune bouteille deau minrale de 1,5L. Dans un deuxime temps, le programme affiche le prix au litre, le prix dun pack deau, sachant quil y a 6 bouteilles, dont une est offerte, ainsi que le prix dune palette de packs deau, sachant quil y a 50 packs dans une palette dont 5 sont offerts. 5 -8 Rv. 443 Principes et mthodes de programmation Les oprateurs D.VIESLET
6 Les procdures et fonctions prdfinies

6.1 Introduction
Tout le monde connat la notation mathmatique sous la forme: y = f (x) Dans cette notation, f est la fonction mathmatique, x est un paramtre ou argument pass la fonction, et y recevra le rsultat de la fonction, appel aussi la valeur de retour de la fonction. Nous parlerons dans ce cas d'une fonction. Par ailleurs, nous avons rgulirement utilis jusqu'ici des instructions comme WRITELN, WRITE,... Le point commun entre ces diffrents ordres est que nous n'attendons pas de rsultat de calcul. Le seul objectif sera d'afficher quelque chose l'cran. En d'autres termes, nous n'attendons pas de valeur de retour d'une telle action mais uniquement qu'une action se ralise. Nous parlerons dans ce cas de procdure. Une fonction a comme objectif de raliser un calcul. Elle accepte gnralement des arguments et possde une valeur de retour. Une procdure ralise une action (plutt qu'un calcul). Elle accepte ou non des arguments mais ne retourne rien. L'utilisation de procdures et fonctions rend le code source plus lisible, surtout lorsqu'il est ncessaire de s'y replonger longtemps aprs l'avoir crit. Ds qu'un programme atteint plus d'une page A4 de code, il devient ainsi difficilement lisible. Cela permet aussi d'viter des squences d'instructions rptitives. Si le mme traitement doit tre rpt plusieurs fois dans un mme programme, nous allons crire une fonction ou une procdure permettant de raliser ce traitement. Ce code sera appel autant de fois que ncessaire mais ne sera crit qu'une seule fois. Nous parlerons de routine quant il s'agit indiffremment d'une fonction ou d'une procdure.
6.2 Les routines mathmatiques

Fonction ABS(nombre) ARCTAN(nombre) COS(nombre) EXP(nombre) FRAC(nombre) INT(nombre) LN(nombre) Explication Retourne la valeur absolue de nombre (sans le signe). Le rsultat est du mme type que l'argument. Retourne l'angle en radians dont la tangente est nombre. Le rsultat est toujours un rel. Retourne le cosinus de nombre (en radians). Le rsultat est toujours un rel. Retourne l'exponentiel de nombre. Le rsultat est toujours un rel. Retourne la partie fractionnaire de nombre. Le rsultat est toujours un rel. Retourne la partie entire de nombre. Le rsultat est toujours un rel. Retourne le logarithme nprien de nombre. Le rsultat est toujours un rel.
D.VIESLET
Principes et mthodes de programmation Les procdures et fonctions prdfinies
6 -1 Rv. 443
ODD(nombre) RANDOMIZE RANDOM(nombre) ROUND(nombre) SIN(nombre) SQR(nombre) SQRT(nombre) TRUNC(nombre)
Dtermine la parit d'un nombre. Initialise le gnrateur de nombres alatoires. Retourne un entier compris entre 0 et nombre-1 (qui doit tre un entier).
Arrondir le rel nombre l'entier le plus proche. Retourne le sinus de nombre en radians. Le rsultat est toujours un rel. Retourne le carr de nombre. Le rsultat est de mme type que l'argument. Retourne la racine carre de nombre. Le rsultat est toujours un rel. Enlve la partie dcimale du rel nombre. Le rsultat est bien sr un entier.
ABS La fonction ABS renvoie la valeur absolue d'un entier ou d'un rel, par exemple,
Abs(-21);
renvoie 21
Abs(-3.5);
renvoie 3.5000000OOOE+00 COS La fonction cosinus renvoie la valeur du cosinus de l'argument exprim en radians
Cos(0);
renvoie 1.0
Cos(3.1415926 / 4);
renvoie 0.0 EXP La fonction Exponentielle calcule la valeur du nombre de Neper (e=2.71828...) leve la puissance de son argument:
Exp(10);
renvoie e a la puissance 10 II n'y a pas de fonction prdfinie en Pascal pour calculer une expression telle que Xn (X exposant n). Cette expression est calcule en utilisant la formule Xn=Exp(n*Ln(X))
6 -2 Rv. 443
D.VIESLET
LN La fonction logarithme calcule le logarithme nprien d'un nombre plus grand que zro. ODD La fonction ODD dtermine la parit d'un nombre, elle renvoie TRUE si le nombre est impair, FALSE sinon. ROUND La fonction round arrondit son argument l'entier le plus proche. Si l'argument est positif, l'arrondi se fait:

vers le haut pour une partie dcimale plus grande ou gale 0.5 vers le bas pour une partie dcimale infrieure 0.5 vers le bas pour une partie dcimale plus grande ou gale 0.5 vers le haut pour une partie dcimale infrieure 0.5
Si l'argument est ngatif, l'arrondi se fait:

SIN La fonction sinus renvoie la valeur du sinus de l'argument, par exemple:

Sin(3.1415926 / 2);
renvoie 1.0 SQR La fonction SQR renvoie le carr de son argument

Sqr(2);
renvoie 4 SQRT Cette fonction renvoie la racine carre de son argument

Sqrt(4);
renvoie 2. TRUNC Cette fonction renvoie la partie entire d'un nombre rel.
Trunc(4.87);
renvoie 4
D.VIESLET
6 -3 Rv. 443
Trunc(-3.4);
renvoie -3
6.3 Les routines pour scalaires

Un type scalaire est un type dans lequel il est possible d'attribuer chaque valeur un prdcesseur et un successeur, exception faite bien videmment pour le premier et le dernier lment. Pour ce type, on pourrait donc numrer toutes les valeurs possibles et les classer selon un ordre. ORD Cette fonction fournit (sous forme d'entier) le numro d'ordre de la valeur passe en paramtre:
Ord(15);
retourne 15
Ord('A');
retourne 65: le code ASCII de la lettre 'A'

Ord(FALSE);
retourne 0. SUCC Cette fonction fournit l'lment suivant si il existe:

Succ(15);
retourne 16
Succ('A');
retourne 'B'
Succ(FALSE);
retourne TRUE PRED Cette fonction fournit l'lment prcdent si il existe:

Pred(15);
retourne 14 6 -4 Rv. 443 Principes et mthodes de programmation Les procdures et fonctions prdfinies D.VIESLET
Pred('A');
retourne '@'
Pred(True);
retourne FALSE
6.4 Les routines pour caractres et chanes

CHR
Function Chr(N: Integer): Char;
Cette fonction renvoie le caractre associ la valeur ASCII donne en argument. Exemple:
Chr(65)
renvoie la caractre 'A'. CONCAT

Function Concat(s1, s2, s3,..., sN: String): String;
Cette fonction concatne les chanes de caractres spcifies s1, s2, etc. en une seule et mme chane. Exemple:
Program ExConcat1; Var s: String; Begin s := Concat('Ceci ', 'est ', 'un ', 'exemple.'); Writeln(s); End;
Remarque: on peut utiliser l'oprateur + pour effectuer cette opration.

Program ExConcat2; Var mot1, mot2: String[20]; texte: String; Begin Write ('Donnez un premier mot: '); Readln(mot1); Write ('Donnez un second Readln(mot2); mot: ');
texte := mot1 + mot2; Writeln('TEXTE : ', texte);
D.VIESLET
6 -5 Rv. 443
texte := mot1 + ' ' + mot2; Writeln('TEXTE: ', texte); texte := Concat(mot1, mot2); Writeln('TEXTE: ', texte); texte := Concat(mot1, ' ', mot2); Writeln('TEXTE: ', texte); End.
COPY
Function Copy(S: String; Debut, Len: Byte): String;
Fonction qui retourne de la chane de caractre S, un nombre Len de caractres partir de la position Debut (dans le sens de la lecture). Exemple:
Program ExCopy1; Var s: String; Begin s := Copy('ABCDEF',2,3); { s = 'BCD' }; End; Program ExCopy2; Var mot: String; Begin Write('Donnez une chaine: '); Readln(mot); Writeln(copy(mot, 2, 4)); End.
DELETE
Procedure Delete(Var S: String; Debut, Len: Byte);
Procdure qui supprime de la chane nomme S, un nombre Len de caractres partir de la position Debut. Exemples:
Program ExDel; Var s: String; Begin s := 'ABCDEF'; Delete(s, 2, 3); End. { s = 'AEF' }
6 -6 Rv. 443
D.VIESLET
Program ExDel2; Var texte: String; Begin texte := Bonjour monsieur'; Writeln('texte avant: ', texte ); Delete(texte, 4, 5); Writeln('texte aprs: ', texte ); End.
Si l'indice donn dpasse la longueur, l'opration sera sans effet. INSERT

Procedure Insert(Source: String; Var S: String; Index: Integer);
Insre l'expression chane Source dans la variable chane S la position position dsigne par Index. LENGTH
Function Length(S: String): Byte;
Fonction qui renvoie la longueur d'une chane: Exemple:

Progran ExLen; Var S: String; Begin S := 'AZERTY'; Writeln(Length(S)); End;
POS
Function Pos(SousChaine, ChainePrincipale: String): Byte;
Fonction qui renvoie sous forme de variable de type byte la position de la souschane dans la chane principale. Si la sous-chane est absente, cette fonction renvoie la valeur 0. Exemples:
Program ExPos1; Var i: Byte; Begin i := Pos('def', 'abcdefgh'); End. { i = 4 }
D.VIESLET
6 -7 Rv. 443
Program ExPos2; Var mot1, mot2: String; Begin; mot1 := 'bonjour monsieur'; mot2 := 'jour'; Writeln(mot1 , ' - ', mot2); Writeln('pos de SI dans mot1: ' ,pos('si' ,mot1)); Writeln('pos de BON dans mot1: ' ,pos('bon',mot1)); Writeln('pos de mot2 dans mot1: ' ,pos(mot2 ,mot1)); End.
Remarque: cette fonction ne renvoie que la position de la premire occurrence. Si la sous-chane apparat plusieurs fois, alors les autres occurrences seront ignores. Pour remdier ce problme, il faut soit supprimer le dbut de la chane, soit crer sa propre fonction de recherche. STR
Procedure Str(X: Width:Decimals; Var S: String);
Procdure qui convertit le nombre entier ou rel X en chane de caractre de nom S.

X est un nombre, entier ou rel. S est la chane accueillant le rsultat de la conversion. Width reprsente la taille minimale de la chane rsultante, avec un alignement droite. Si Width = 0, alors il n'est pas pris en compte. Decimals reprsente le nombre de chiffres aprs la virgule qui doivent tre utiliss pour la conversion d'un nombre rel. Width et Decimals sont des paramtres facultatifs. Toutefois, si vous dsirez indiquer Decimals, vous devez ncessairement mettre Width.
Par dfaut, la conversion d'un nombre rel s'effectue en utilisant la notation mmmmmmmmmmmmmmExxxx, o mmmmmmmmmmmmmm est la mantisse et xxxx l'exposant (par exemple, 12.3 = 1.23000000000000E+0001). Exemple:
Program ExStr; Var s:String; Begin Str(123, s); Str(1.23, s); Str(1.23:6:2, s); Str(1.23:0:3, s); End. { { { { s s s s = = = = '123' } '1.23000000000000E+0001' } ' 1.23' } '1.230' }
UPCASE
Function Upcase (C: Char): Char;
6 -8 Rv. 443
D.VIESLET
Convertit un caractre en majuscule. VAL

Procedure Val (S: String; Var X; Var E: Integer);
Procdure qui convertit la chane de caractre de nom S en un nombre entier ou rel X et renvoie un code erreur E (de type INTEGER) qui est gal 0 si la conversion est possible. S est la chane convertir. Pour qu'il n'y ait pas d'erreur, il faut que celle-ci contiennent un nombre, qu'il soit entier (dcimal ou hexadcimal), ou virgule. X est la variable qui contiendra le nombre converti. Ce peut tre un entier (SHORTINT, BYTE, INTEGER, WORD, LONGINT), ou bien un rel (REAL , SINGLE, DOUBLE, EXTENDED, COMP). E est le code d'erreur. Si la chane S contient bien un nombre et que X est du type attendu, alors E vaut 0. Sinon, E correspond la position de la premire erreur dans la chane S.
Program ExVal; Var i: w: r: e: Begin Val('123', i, e); Val('1.23', r, e); Val('1.2E3', r, e); Val('-123', w, e); Val('1.23', i, e); Val('12a', i, e); Val('$12A', i, e); End. { { { { { { { i r r w i i i = = = = = = = 123 1.23 1200 ? ? ? $12A ; ; ; ; ; ; ; e e e e e e e = = = = = = = 0 0 0 1 2 3 0 } } } } } } } Integer; Word; Real; Integer;
Exemple:
6.5 Les routines pour dates et heures

Ces routines permettent de lire et modifier l'horloge du PC. Note: toutes les instructions qui suivent ncessitent l'unit dos. GETDATE
Procedure GetDate(an, mois, jour, joursem: Word);
Pour obtenir la date courante du systme, avec an qui est le numro de l'anne (compris entre 1980 et 2099), mois: le numro du mois (1 12), jour: le numro du
D.VIESLET
6 -9 Rv. 443
jour dans le mois (1 31) et joursem: le numro du jour dans la semaine (0 6, le zro correspondant au samedi).
Procedure SetDate(an, mois, jour: Word);
Pour changer la date du systme. Ici, les variables obissent aux mmes conditions dcrites prcdemment. Si une date entre est invalide, elle ne sera pas prise en compte et la date courante restera inchange.
Procedure GetTime(heure, minute, seconde, cent: Word);
Pour obtenir l'heure courante avec heure qui est le numro de l'heure (comprise entre 0 et 23), minute: numro de la minute (0 59), seconde: numro de la seconde (0 59) et cent: les centimes de seconde (0 99).
Procedure SetTime(heure, minute, seconde, cent: Word);
Pour changer l'heure systme. Les variables obissant aux mmes conditions dcrites plus haut. Si une heure entre est invalide, elle ne sera pas prise en compte et l'heure courante restera inchange.
6 -10 Rv. 443
D.VIESLET
7 Les structures alternatives

Les instructions d'un programme sont excutes en squence (les unes aprs les autres, dans l'ordre dans lequel elles sont crites). Il est parfois ncessaire de rompre cette excution squentielle, notamment lorsque le programme contient plusieurs suites d'instructions chacune d'elles ne devant tre excute que lorsque certaines conditions sont remplies. Ce rle est assur par les structures alternatives appeles aussi structures conditionnelles ou slectives. Elles sont au nombre de deux:

IF ... THEN ... ELSE CASE ... OF ... ELSE
7.1 La structure IF ... THEN ... ELSE

Cette commande permet de soumettre l'excution d'instructions une condition. Si la condition est vraie, le code est excut. La condition doit tre une expression boolenne. La syntaxe est la suivante:
If Condition Then instruction_si_vrai;
instruction_si_vrai sera excut si la condition est remplie c'est dire si l'expression boolenne vaut vrai. Si on souhaite excuter des instructions dans le cas o la condition est fausse, il faut complter linstruction IF ... THEN dune instruction ELSE. La syntaxe devient:
If Condition Then instruction_si_vrai Else instruction_si_faux;
En Pascal toutes les instructions doivent se terminer par un ; . Dans le cas de l'instruction IF ... THEN .... ELSE, le ; avant l'instruction ELSE est interdit. Il s'agit d'un exception la rgle nonce au paragraphe 2.3.3 Le corps du programme. Les instructions peuvent tre des simples ou des blocs dlimits par BEGIN et END.
If Condition Then Begin instruction1_si_vrai; ..... instructionN_si_vrai; End Else Begin instruction1_si_faux; ..... instructionN_si_faux; End;
La condition est une expression boolenne pouvant contenir des oprateurs de comparaison (Voir 5.4 Oprateurs de comparaison) et des oprateurs boolens (Voir 5.7 Oprateurs boolens).
D.VIESLET
Principes et mthodes de programmation Les structures alternatives
7 -1 Rv. 443
Exemples:
Program exemple3a; Var ch: Integer; Begin Write(' Entrez un entier pas trop grand: '); Readln(ch); If ch < 100 Then Writeln(ch,' est infrieur cent.'); End.
Ce programme exemple3a compare un chiffre donn par l'utilisateur au scalaire 100. Si le chiffre est infrieur 100, alors il affiche cette information l'cran, sinon il ne fait rien. Cette commande peut tre complte d'une instruction ELSE qui reprendra l'instruction excuter si la condition est fausse.
Program exemple3b; Var ch: Integer; Begin Write(' Entrez un entier pas trop grand: '); Readln(ch); If ch < 100 Then Writeln(ch,' est infrieur cent.') Else Writeln(ch,' est suprieur ou gal cent.' ); End.
Ce programme exemple3b compare un chiffre donn par l'utilisateur au scalaire 100. Si le chiffre est infrieur 100, alors il affiche cette information l'cran, sinon il affiche que le chiffre entr est suprieur ou gale 100. L'instruction qui prcde le ELSE ne peut pas tre termine par un pont-virgule. Il s'agit d'une exception la grammaire du langage Pascal. Il est possible d'encadrer ces instructions excuter des mots cls BEGIN et END. Ceci est strictement ncessaire quand il faut excuter plusieurs instructions.
Program exemple3c; Var ch: Integer; Begin Write(' Entrez un entier pas trop grand: '); Readln{ch); If ch < 100 Then Begin Writeln(ch, ' est infrieur cent.' ); End Else Begin Writeln(ch, ' est suprieur ou gale cent. '); End; End.
7 -2 Rv. 443
D.VIESLET
Ce programme exemple3c fait strictement la mme chose que le 3b mais sa structure permet d'insrer plusieurs instructions dans les blocs THEN et ELSE. Il est galement possible d'insrer d'autres structures IF dans un ELSE. On parle alors de structures conditionnelles imbriques. L'exemple qui suit illustre cette possibilit.
Program exemple3d; Var chiffre: Integer; Begin Write('Entrez un entier pas trop grand: '); Readln{chiffre); If chiffre < 100 Then Begin Writeln(chiffre,' est infrieur cent.' ); End Else If chiffre < 200 Then Begin Writeln(chiffre,' est infrieur deux cent' ); Writeln('Mais il est suprieur ou gal cent.'); End Else Writeln{chiffre,' est suprieur ou gal 200'); End.
Voici d'autres exemples d'utilisation de cette structure. Ce programme dtermine si les deux nombres sont donns en ordre croissant ou non.
Program exemple_If_1; Var n, p: Integer; Begin Writeln('Donnez deux nombres entiers: '); Readln(n); Readln(p); If n < p Then Writeln('Croissant') Else Writeln('Dcroissant ou gal'); Writeln('Merci'); End.
D.VIESLET
7 -3 Rv. 443
Ce programme dtermine si les deux nombres sont donns en ordre croissant ou non et affiche le maximum.
Program exemple_If_2; Var n, p, max: Integer; Begin Writeln('Donnez deux nombres entiers: '); Readln(n); Readln(p); If n < p Then Begin max := p; Writeln('Croissant !') End Else Begin max := n; Writeln('Dcroissant ou gal!'); End; Writeln('Le maximum est ', max ); End.
Ce programme demande deux mots l'utilisateur et les trie par ordre alphabtique.
Program exemple_If_3; Var mot1, mot2, mot: String; Begin Write ('Donnez un premier mot: '); Readln(motl); Write ('Donnez un second Readln(mot2); If mot_1 > mot_2 Then Begin mot := mot1; motl := mot2; mot2 := mot; End; Writeln('Voici vos deux mots tris:'); Writeln(mot1); Writeln(mot2); End. mot: ');
7 -4 Rv. 443
D.VIESLET
Program exemple_If_4; Var a, b, c: Integer; Begin a := 5; b := 3; c := 99; If (a = 5) Or (b > If (a < 5) And(b > If (a = 5) And(b = If (c <> 6)Or (b > Else Writeln('E'); If (b = 3) And(c = If (a = 1) Or (b = If Not((a < 5) And End. 2) 2) 2) 9) Then Then Then Then Writeln('A'); Writeln('B'); Writeln('C'); Writeln('D')
99)Then Writeln('F'); 2) Then Writeln('G'); (b > 2)) Then Writeln('H');
Exercice 9 Quizz 1 Considrez le programme ci-dessus. Dterminez quelles seront les lettres que ce programme affichera l'cran. Encodez ce code source et excutez le programme pour vrification. Mme question en affectant a:=4; b:=10; c:=100; L'exemple suivant utilise une variable intermdiaire de type boolen.
Program exemple_If_5; Var n, p: Integer; result: Boolean; Begin Writeln("donnez 2 entiers:'); Readln(n); Readln(p); result := n < p; If result = true Then Writeln('croissant !') Else Writeln('droissant ou gal !'); End.
D.VIESLET
7 -5 Rv. 443
Il est possible d'imbriquer plusieurs IF ... THEN ... ELSE

Program exemple_If_6; Var n, p: Integer; Begin Write('donnez 2 entiers: '); Readln(n); Readln(p); If n < p Then Writeln('Croissants !') Else If n > p Then Writeln('Dcroissants !') Else Writeln('Egaux !'); End.
Exercice 10 Pair ou impair ? Ecrivez un programme qui dit si l'entier donn par l'utilisateur est pair ou impair. Exercice 11 Les examens Ecrivez un programme qui demande l'utilisateur les notes obtenues par l'tudiant dans trois matires diffrentes. Ces notes sont exprimes sur un maximum de 100. Le programme calcule la moyenne de ces trois notes. Si cette moyenne est:

strictement infrieure 60, affichez Echec comprise entre 60 inclus et 70 exclus, affichez Satisfaction comprise entre 70 inclus et 80 exclus, affichez Distinction comprise entre 80 inclus et 90 exclus, affichez Grande distinction comprise entre 80 inclus et 100 exclus, affichez La plus grande distinction de 100, affichez Perfection Exercice 12 L'ge du capitaine
Ecrivez un programme qui demande la date de naissance d'une personne (jour, mois, anne). Calculez ensuite son ge en fonction de la date du jour. Pour connatre la date du jour, utilisez la fonction now ou getdate . L'ge vaut la diffrence entre l'anne courante et l'anne de naissance aprs son anniversaire ou cette diffrence moins un avant.
7 -6 Rv. 443
D.VIESLET
Exercice 13 Le colis postal Ecrivez un programme qui calcule le cot de l'expdition d'un objet par la poste. Ce cot vaudra le prix de la bote d'emballage plus le prix des timbres. Il existe des botes de diffrentes dimensions: Modles XS S M L XL jusqu Dimensions (L x l x H) 155 x 115 x 74 230 x 155 x 74 263 x 188 x 98 310 x 220 x 98 385 x 290 x 135 2 kg 1 timbre, 5 kg 2 timbres, 10 kg 3 timbres, 20 kg 4 timbres, 30 kg 5 timbres. Le prix unitaire d'un timbre est de 4,30. Ecrivez un programme qui demande l'utilisateur la longueur, largeur, hauteur et le poids de l'objet envoyer. En fonction des dimensions, dterminez le modle de bote utiliser (la plus petite possible). En fonction du poids, dterminez le nombre de timbres. Si une ou plusieurs dimensions de l'objet excdent celles de la plus grande bote ou si le poids dpasse le poids maximum, affichez le message d'erreur Envoi impossible. sinon, calculez et affichez le cot de l'envoi. Exercice 14 Le colis postal amlior Modifiez le programme prcdent pour que l'utilisateur ne doive plus respecter un ordre d'introduction des dimensions. L'utilisateur introduit les trois dimensions de son objet dans un ordre quelconque. Le programme dtermine que la longueur est le plus grande des dimensions introduites, la hauteur la plus petite et la largeur, l'intermdiaire. Prix () 1,30 1,40 1,50 1,60 1,80
En ce qui concerne les timbres, leur nombre dpend du poids:
7.2 La structure CASE ... OF ... ELSE

Cette instruction compare la valeur d'une variable scalaire (entier, caractre ou de manire gnrale de type intervalle ou numr) des constantes. En fonction du rsultat de la comparaison, des instructions sont excutes ou non. La syntaxe est:
Case expression Of domaine_1: instruction_1; domaine_2: instruction_2; ... domaine_X: instruction_X; End;
D.VIESLET
7 -7 Rv. 443
Instruction_1 sera excute si lexpression a la valeur_1, instruction_2 si elle a la valeur_2, et ainsi de suite. Les valeurs peuvent tre des intervalles. Si on souhaite excuter des instructions dans le cas o l'expression ne correspond aucune des valeurs, il faut complter linstruction CASE ... OF dune instruction ELSE. La syntaxe devient:
Case expression Of domaine_1: instruction_1; domaine_2: instruction_2; ... domaine_X: instruction_X; Else autre_instruction; End;
Le point-virgule ; pour terminer l'instruction qui prcde le ELSE du CASE ... OF est facultatif. Le choix de le placer est laiss l'apprciation du programmeur. Les instructions peuvent tre des simples ou des blocs dlimits par BEGIN et END.
Case expression Of domaine_1: Begin instruction_1_1; instruction_1_2; ... End; domaine_2: Begin instruction_2_1; instruction_2_2; ... End; Else Begin autre_instruction_1; autre_instruction_2; ... End; End;
La structure CASE ... OF ne permet une comparaison qu'avec des constantes. L'expression et les domaines de comparaison doivent tre du mme type scalaire.
7 -8 Rv. 443
D.VIESLET
Exemples d'utilisation:
Program Jour; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J: Byte; Begin Write('ENTREZ LE CODE DU JOUR: Reanln(J); Case J Of 1: Writeln('LUNDI'); 2: Writeln('MARDI'); 3: Writeln('MERCREDI'); 4: Writeln('JEUDI'); 5: Writeln('VENDREDI'); 6: Writeln('SAMEDI'); 7: Writeln('DIMANCHE'); End; Writeln('Au revoir.'); End. ');
Si la valeur introduite n'est pas reprise dans les diffrentes valeurs, le programme continuera l'instruction suivant le END terminant le CASE ... OF. Dans ce cas, le programme affichera simplement Au revoir. . Pour excuter une ou plusieurs instructions dans ce cas, il faut utiliser l'instruction optionnelle ELSE.
Program Jour; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J: Byte; Begin Write('ENTREZ LE CODE DU JOUR: Reanln(J); Case J Of 1: Writeln('LUNDI'); 2: Writeln('MARDI'); 3: Writeln('MERCREDI'); 4: Writeln('JEUDI'); 5: Writeln('VENDREDI'); 6: Writeln('SAMEDI'); 7: Writeln('DIMANCHE'); Else Writeln('Erreur'); End; Writeln('Au revoir.'); End. ');
Si la valeur introduite n'est pas reprise dans les diffrentes valeurs, le programme affichera d'abord Erreur et ensuite Au revoir. .
D.VIESLET
7 -9 Rv. 443
Il est possible de spcifier une liste de valeurs. Elles doivent tre spares par des virgules.
Program Jour; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J: Byte; Begin Write('ENTREZ LE CODE DU JOUR: Reanln(J); ');
Case J Of 1, 2, 3, 4, 5: Writeln('On travaille'); 6, 7: Writeln('C''est le week-end'); Else Writeln('Erreur'); End; End.
Ou encore:
Write('Donnez un nombre compris entre 1 et 10 inclus: '); Readln(NB); Case NB Of 2,4,6,8,10: Writeln('ce nombre est pair'); 1,3,5,7,9: Writeln('ce nombre est impair') Else Writeln('On vous a dit entre 1 et 10!!!!'); End;
Les valeurs de comparaison peuvent tre un intervalle. Il faut alors donner le minimum et maximum spar par deux fois le symbole point.
Program Jour; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J: Byte; Begin Write('ENTREZ LE CODE DU JOUR: Reanln(J); ');
Case J Of 1..5: Writeln('On travaille'); 6..7: Writeln('C''est le week-end'); Else Writeln('Erreur'); End; End.
ou encore:
Write('Donnez un nombre compris entre -100 et +100: '); Readln(NB); Case NB Of 0: Writeln('Nul'); 1..100: Writeln('Positif ); -1..-100: Writeln('Ngatif) Else Writeln('Erreur'); End;
7 -10 Rv. 443
D.VIESLET
Il est possible d'utiliser la fois une valeur unique, une liste de valeurs et des intervalles dans la mme instruction.
Case a + b Of 1 : a := b; 3..6: b := a; 8, 9: Begin a := 0; b := 0; End; 10..13, 15: b := 0; End;
Exercice 15 Quizz 2 Dterminez quelles seront les valeurs des variables a et b aprs excution du programme si en dbut, a et b valent respectivement 0 et 1; 4 et 4; 2 et 2; 7 et 8. Ecrivez un programme qui demande ces deux valeurs, excute le code donn en exemple et affiche les deux variables. Vrifiez votre rponse. D'autres exemples:
Program exemplecasel; Var n: Integer; Begin Writeln('Donnez un entier: '); Readln(n); Case n of 1,2: Writeln('Petit !'); 3..10: Writeln('Moyen !'); 11..50: Writeln('Grand !') Else Writeln('Autre nombre !') End; End. Program exemple_Case_2 Var c: Char; Begin Write('Donnez un caractre: '); Readln(c); Case c of 'a'..'z': Writeln('Minuscule !'); 'A'..'Z': Writeln('Majuscule !'); Else Begin Writeln('Caractre non rpertori !'); Writeln('Code ASCII: ',ord(c)); End; End; End.
D.VIESLET
7 -11 Rv. 443
Program exemple4; Var age: Integer; Begin Write('Entrez votre ge: '); Readln(age); Case age of 18: Writeln(' La majorit, pile-poil'); 0..17: Writeln(' Venez moi, les petits enfants... '); 60..99: Writeln(' Les infirmires vous laissent jouer avec un ordinateur votre ge ?!!!'); Else Writeln(' Vous tes d''un autre ge... '); End; End.
L'instruction ci-dessous est correcte mais n'est pas conseille:

Case n Of 1.. 5:Write('Petit'); 3..10:Write('Moyen'); End;
En effet, les valeurs 3, 4 et 5 rpondent aux deux conditions. Si nous entrons la valeur 4, c'est "Moyen" qui s'affichera. Une seule instruction sera donc excute. La structure CASE ... OF vous permet d'crire un code qui utilise beaucoup moins d'instructions que IF ... THEN ... ELSE, rendant ce code beaucoup plus lisible. Considrez la portion de code suivante crite en utilisant IF ... THEN ... ELSE,
If oper = '*' Then Result := number1 * number2 Else If oper = '/' Then Result := number1 / number2 Else If oper = '+' Then Result := number1 + number2 Else If oper = '-' Then Result := number1 - number2 Else invalid_operator = 1;
La rcriture en utilisant CASE ... OF donne:

Case '*': '/': '+': '-': Else End; oper Of Result:= number1 Result:= number1 Result:= number1 Result:= number1 invalid_operator * number2; / number2; + number2; - number2; := 1;
7 -12 Rv. 443
D.VIESLET
Les programmes suivants qui fonctionnent de la mme manire: Avec l'instruction IF ... THEN
Program Semaine1; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J: Byte; Begin Write('CHOISIR UN CHIFFRE DE 1 ... 7: '); Reanln(J); If (J < 1) Or (J > 7) Then Writeln('INEXISTANT'); If J = 1 Then Writeln('LUNDI'); If J = 2 Then Writeln('MARDI'); If J = 3 Then Writeln('MERCREDI'); If J = 4 Then Writeln('JEUDI'); If J = 5 Then Writeln('VENDREDI'); If J = 6 Then Writeln('SAMEDI'); If J = 7 Then Writeln('DIMANCHE'); End.
Avec l'instruction IF ... THEN ... ELSE

Program Semaine2; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J:Byte; Begin Write('CHOISIR UN CHIFFRE DE 1 ... 7: '); Reanln(J); If J = 1 Then Writeln('LUNDI') Else If J = 2 Then Writeln('MARDI') Else If J = 3 Then Writeln('MERCREDI') Else If J = 4 Then Writeln('JEUDI') Else If J = 5 Then Writeln('VENDREDI') Else If J = 6 Then Writeln('SAMEDI') Else If J = 7 Then Writeln('DIMANCHE') Else Writeln('INEXISTANT'); End.
Avec l'instruction CASE ... OF ... ELSE

Program Semaine3; {EXERCICE SUR LES JOURS DE LA SEMAINE} Var J:Byte; Begin Write('ENTREZ LE CODE DU JOUR: Reanln(J); Case J Of 1: Writeln('LUNDI'); 2: Writeln('MARD'); 3: Writeln('MERCREDI'); 4: Writeln('JEUDI'); 5: Writeln('VENDREDI'); 6: Writeln('SAMEDI'); 7: Writeln('DIMANCHE'); Else Writeln('INEXISTANT'); End; End. ');
D.VIESLET
7 -13 Rv. 443
Exercice 16 Conversion de devises Permettre aprs introduction du montant en euros et du code de la devise d'obtenir la valeur du change de la monnaie choisie. Suivant la quantit d'euros changer, la parit de la devise se modifie. Les devises sont des constantes assignes au sein mme du programme. Codes des devises: 1 2 3 4 5 Parit des devises: DEVISE Moins de 499 500 1000 plus de 1000 Dollar Amricain 1,4345 1,4376 1,4412 Bath Thalandais 1,6654 1,6682 1,6701 Dollar Canadien 43,254 43,540 43,836 Yen Japonais 163,99 164,37 164,45 Dong Vietnamien 23052 23080 23094 Afficher le code et le nom des devises. Aprs traitement, afficher le montant introduit en , la valeur du change et le nom de la devise. Exercice 17 Le salaire d'un reprsentant Le salaire des reprsentants de la firme Vend DeTout se calcule de la manire suivante:

Dollar Amricain Bath Thalandais Dollar Canadien Yen Japonais Dong Vietnamien
Fixe Brut de 1700 Commissions sur le chiffre d'affaires mensuel:

0 9
% si le chiffre est < 2500 % si le chiffre est > ou = 12500 mais < 37500
7,5 % si le chiffre est > ou = 2500 mais < 12500 11,3% si le chiffre est > ou = 37500
Prime d'anciennet accorde au reprsentant en fonction de son anciennet ( par anne) dans l'entreprise.

< 2 ans 70 fixe >= 2 ans mais < 7 ans 70 fixe + 10 par anne au dessus de 2 ans >= 7 ans mais < 15 ans 120 fixe + 12 par anne au dessus de 7 ans >= 15 ans 216 fixe + 14 par anne au dessus de 15 ans plafonn 326
Ecrivez le programme qui demande l'utilisateur le chiffre d'affaires et l'anciennet du reprsentant. Calculez et affichez ensuite son salaire brut.
7 -14 Rv. 443
D.VIESLET
Exercice 18 Les charges professionnelles forfaitaires Avant le calcul de limpt des personnes physiques, le montant du revenu brut annuel est diminu dun montant correspondant aux charges professionnelles forfaitaires. Ce montant est calcul par lapplication dun pourcentage aux tranches salariales. Un plafond est prvu. Pour les salaris, la dduction des charges professionnelles forfaitaires se prsente actuellement comme suit: Minimum Maximum Pourcentage 0 4790 25% 4790 9520 10% 9520 15850 5% 15850 3% Le plafond est toutefois plac 3.200,00 EUR. Ecrivez un programme qui demande l'utilisateur le montant du revenu annuel brut et calcule le montant des charges professionnelles dductibles.
D.VIESLET
7 -15 Rv. 443
8 Les structures itratives

Jusqu' prsent, nous avons tudi les instructions squentielles (excutes dans l'ordre o elles sont crites) et les instructions alternatives (excutes ou non en fonction d'une condition). Nous allons prsent tudier les instructions rptitives ou itratives c'est dire celles qui nous permettront d'excuter plusieurs fois une squence. Elles sont au nombre de trois:

FOR ... DO WHILE ... DO REPEAT ... UNTIL
Si le nombre de rptitions est connu avant le dbut du traitement rptitif, on utilise l'instruction FOR ... DO. Dans les autres cas, on utilisera les instructions REPEAT ... UNTIL ou WHILE ... DO.
8.1 La structure FOR ... DO

Cette structure permet d'incrmenter ou de dcrmenter une variable de contrle d'une valeur une autre et d'excuter une ou des instructions entre chaque pas. Les valeurs extremum doivent tre des scalaires. C'est dire de type entier, caractre ou d'une manire plus gnrale numr ou intervalle. La boucle n'excute les instructions de son bloc interne que si la valeur infrieure est effectivement infrieure ou gale celle de la borne suprieure. Le pas de variation est l'unit et ne peut pas tre chang. Cette structure itrative sera utilise quand on connat l'avance le nombre de boucles effectuer. L'instruction FOR ... DO permet d'excuter, de manire rpte, une instruction ou une squence d'instructions en notifiant la valeur d'une variable de contrle puis en la comparant la valeur limite avant chaque dbut de la boucle. La syntaxe est la suivante:
For variable_controle:=valeur_inf To valeur_sup Do instruction;
ou
For variable_controle:=valeur_sup Downto valeur_inf Do instruction;
Si plusieurs instructions doivent tre rptes:

For variable_controle:=valeur_inf To valeur_sup Do Begin Instr1; Instr2; ... End; For variable_controle:=valeur_sup Downto valeur_inf Do Begin Instr1; Instr2; ... End;
D.VIESLET
Principes et mthodes de programmation Les structures itratives
8 -1 Rv. 443
Le TO incrmente la variable de contrle de la valeur infrieure pour atteindre la valeur suprieure (progression ascendante). Le DOWNTO dcrmente la variable de contrle de la valeur suprieure pour atteindre la valeur infrieure (progression descendante). Remarques: L'instruction FOR .. DO indique que le corps de l'instruction doit tre excut plusieurs fois, tandis que la variable de contrle suit une progression. La variable de contrle, les valeurs initiale et finale doivent tre du mme type. Si la valeur initiale est suprieure la valeur finale avec TO ou si la valeur finale est infrieure la valeur initiale avec DOWNTO l'instruction n'est pas excute. Il est impossible de modifier la valeur de la variable de contrle dans les instructions contenues dans la structure FOR ... DO. Lorsqu'une instruction FOR ... DO se trouve dans une procdure ou une fonction, la variable constituant l'indice de la boucle doit obligatoirement tre dclare localement la procdure ou la fonction. Exemples:
Program exemplefor1; Var n: Integer; Begin For n := 1 To 8 Do Writeln(n,' a pour triple: ', 3*n, '.'); End. Program exemplefor2; Var n: Integer; Begin For n := 8 downto 1 Do Writeln(n,' a pour triple: ', 3*n, '.') End. Program alphabet; Var c: Char; Begin For c:= 'a' To 'z' Do Write(c,' '); End. Program prgString; Var mot: String; i: Integer;
Begin Write('Donnez une phrase: '); Readln(mot); For i := 1 To Length(mot) Do Writeln(Copy(mot, 1, i)); End.
8 -2 Rv. 443
D.VIESLET
Exercice 19 La table de multiplication Demander l'utilisateur un nombre entier. Afficher ensuite la table de multiplication de ce nombre de 1 20. Exemple 1 * 17 = 17 2 * 17 = 34 ............ 20 * 17 = 340 Exercice 20 L'alphabet Ecrire un programme qui affiche tous les caractres dont le code ASCII est compris entre deux valeurs fournies par l'utilisateur. Exercice 21 La moyenne de la classe (FOR) Permettre aprs introduction du nombre des lves, d'introduire la note d'examen de chaque lve sur 100.

Calculer et afficher la moyenne de la classe. Calculer et afficher le nombre d'lves ayant obtenu un rsultat suprieur 75.
Modifiez le programme de manire afficher non plus le nombre d'lves ayant obtenu un rsultat suprieur 75 mais

le nombre d'checs (rsultat infrieur 60) le nombre d'lves ayant obtenu une satisfaction (rsultat compris entre 60 inclus et 70 exclus) le nombre d'lves ayant obtenu une distinction (rsultat compris entre 70 inclus et 80 exclus) le nombre d'lves ayant obtenu une grande distinction (rsultat compris entre 80 inclus et 90 exclus) le nombre d'lves ayant obtenu la plus grande distinction (rsultat suprieur ou gal 90) Exercice 22 Les toiles en ligne (FOR)
Le programme demande un nombre l'utilisateur. Celui-ci doit tre compris entre 1 et 24. Si ce n'est pas le cas, afficher le message d'erreur Valeur errone. Au revoir. et quitter le programme. Si c'est le cas, afficher une ligne comportant ce nombre d'toiles ( * ). Exemples d'excution: Donnez un nombre ? 100 Valeur errone. Au revoir. Donnez un nombre ? 14 **************
D.VIESLET
8 -3 Rv. 443
Exercice 23 Les toiles en triangle (FOR) Le programme demande un nombre l'utilisateur. Celui-ci doit tre compris entre 1 et 24. Si ce n'est pas le cas, afficher le message d'erreur Valeur errone. Au revoir. et quitter le programme. Si c'est le cas, afficher ce nombre de lignes. Chaque ligne devra contenir un nombre croissant d'toiles ( * )allant de 1 au nombre spcifi. Exemples d'excution: Donnez un nombre ? 100 Valeur errone. Au revoir. Donnez un nombre ? 4 * ** *** **** Exercice 24 La factorielle (FOR) Ecrire un programme qui calcule et affiche la factorielle d'un nombre donn par l'utilisateur. Exemples d'excution: Donnez un nombre ? 4 La factorielle de 4 vaut 24 Exercice 25 Le nombre premier (FOR) Ecrire un programme affiche si le nombre donn par l'utilisateur est premier ou non. Exemples d'excution: Donnez un nombre ? 4 4 n'est pas un nombre premier.
8.2 La structure WHILE ... DO

La structure WHILE rpte une instruction ou bloc d'instruction tant qu'une condition est vraie. On value la condition avant d'excuter une ou des instructions, c'est-dire qu'on peut ne pas entrer dans la structure de rptition si le condition n'est pas vrifie au dpart. Lorsque cette condition devient fausse, l'excution du programme se poursuit l'instruction qui suit. De plus, au moins une variable de la condition doit tre sujette modification au sein de la structure de rptition pour qu'on puisse en sortir. Le nombre de rptitions de la boucle n'est pas nceaaairement connu l'avance. La syntaxe est la suivante:
While expression Do instruction;
Linstruction sera excute tant que lexpression est vraie. L'expression doit tre du type boolen et est rvalue aprs chaque excution de l'instruction.
8 -4 Rv. 443
D.VIESLET
Les instructions peuvent tre des simples ou des blocs dlimits par BEGIN et END (ce qui est le cas le plus frquent). La syntaxe devient:
While expression Do Begin instruction1; instruction2; ... instructionN; End;
Le test de lexpression se fait au dpart de la boucle. Si lexpression est fausse ds le dpart, les instructions ne sont pas excutes. Il faut toujours prvoir une modification de lexpression dans une ou plusieurs instructions de la boucle. Cette modification doit rendre lexpression fausse faute de quoi le programme bouclera indfiniment. Dans cet exemple, les nombres de 0 9999 sont affichs l'cran:
Program DemoWhile1 Var nombre: Integer; Begin Nombre:=0; While nombre < 10000 Do Begin Writeln(nombre); nombre := nombre+1; End; End.
Exemples de boucles qui se rptent indfiniment:

i:=0; While i>=0 Do i:=i+1; i:=0;j:=0; While i<=0 Do j:=j+1; While True Do .......;
Autres exemples:
Program DemoWhile2; Var Nbre: Real; Begin Nbre:=-1; While (Nbre<0) OR (Nbre>100000 ) Do Begin Write(' INTRODUIRE UN NOMBRE DE 0 100000: '); Readln(Nbre); End; Writeln('LE NOMBRE INTRODUIT EST: ',NBRE:5:2); End.
D.VIESLET
8 -5 Rv. 443
Program DemoWhile3 Var somme,nombre: Integer; Begin somme := 0; While somme < 100 Do Begin Write('Donnez un nombre: '); Readln(nombre); somme := somme + nombre; End; Writeln('Somme des nombres: ',somme); End. Program DemoWhile4 Var code: Boolean; essai: String; Const Begin code:=false;{facultatif, la valeur false est donne par dfaut} While code=false Do Begin Write('Entrez le code secret: '); Readln(essai); If essai=levraicode Then code :=true; End; End. Program ExDel3; Var texte: String[80]; place: Integer; lettre: Char; Begin Write('Donnez un mot: '); Readln(texte); Write('Donnez le caractre effacer: '); Readln(lettre); place:= pos(lettre,texte); While place <> 0 Do Begin delete(texte,place,1); place:= pos(lettre,texte); End; Writeln('texte aprs modification: ',texte); End. levraicode='password';
8 -6 Rv. 443
D.VIESLET
Exercice 26 La division Ecrivez un programme qui effectue la division entire de deux entiers par des soustractions successives. Affichez le quotient et le reste. Exercice 27 Le mois Ecrivez un programme demande une valeur comprise entre 1 et 12. Tant que c'est le cas, le programme affiche le nom du mois correspondant et se termine sinon. Exercice 28 La moyenne de la classe (WHILE) Permettre aprs introduction du nombre des lves, d'introduire la note d'examen de chaque lve sur 100.


le nombre d'checs (rsultat infrieur 60) le nombre d'lves ayant obtenu une satisfaction (rsultat compris entre 60 inclus et 70 exclus) le nombre d'lves ayant obtenu une distinction (rsultat compris entre 70 inclus et 80 exclus) le nombre d'lves ayant obtenu une grande distinction (rsultat compris entre 80 inclus et 90 exclus) le nombre d'lves ayant obtenu la plus grande distinction (rsultat suprieur ou gal 90) Exercice 29 Les toiles en ligne (WHILE)
Le programme demande un nombre l'utilisateur. Celui-ci doit tre compris entre 1 et 24. Si ce n'est pas le cas, afficher le message d'erreur Valeur errone. Au revoir. et quitter le programme. Si c'est le cas, afficher une ligne comportant ce nombre d'toiles ( * ). Exemples d'excution: Donnez un nombre ? 100 Valeur errone. Au revoir. Donnez un nombre ? 14 **************
D.VIESLET
8 -7 Rv. 443
Exercice 30 Les toiles en triangle (WHILE) Le programme demande un nombre l'utilisateur. Celui-ci doit tre compris entre 1 et 24. Si ce n'est pas le cas, afficher le message d'erreur Valeur errone. Au revoir. et quitter le programme. Si c'est le cas, afficher ce nombre de lignes. Chaque ligne devra contenir un nombre croissant d'toiles ( * )allant de 1 au nombre spcifi. Exemples d'excution: Donnez un nombre ? 100 Valeur errone. Au revoir. Donnez un nombre ? 3 * ** *** Exercice 31 La factorielle (WHILE) Ecrire un programme qui calcule et affiche la factorielle d'un nombre donn par l'utilisateur. Exemples d'excution: Donnez un nombre ? 4 La factorielle de 4 vaut 24 Exercice 32 Le nombre premier (WHILE) Ecrire un programme affiche si le nombre donn par l'utilisateur est premier ou non. Exemples d'excution: Donnez un nombre ? 4 4 n'est pas un nombre premier. La racine carre d'un nombre N se calcule de manire itrative par la formule X
j 1
X j N X j 1
X j est la valeur approche de X

j 1
N l'itration j. est la valeur approche de N l'itration suivante j+1.

X
j 1
Si on remplace X j par Les diffrentes valeurs En remplaant X X N X 1 2 X X =XN X 2=N X = N X= 8 -8 Rv. 443 X
, on obtient
X X
j 2
et ainsi de suite.
X j X .
j n
vont tendre vers
N .
j 1
Dmonstration: si le procd converge, on a

j 1
et X j par X , on trouve
D.VIESLET
X j est initialise une valeur de dpart X 0 qui est une appximation de L'erreur relative entre deux itrations est dfinie par Exemple numrique: calcul de Xj 1,00000000 2,00000000 1,66666667 1,75000000 1,72727273 1,73333333 1,73170732 1,73214286 1,73202614 1,73205742 1,73204904 1,73205128 1,73205068 X E j 1=
N .
j 1
X
j1
3 en partant de l'approximation X 0 =1
j 1
E j1 0,50000000 0,20000000 0,04761905 0,01315789 0,00349650 0,00093897 0,00025145 0,00006739 0,00001806 0,00000484 0,00000130 0,00000100 0,00000100
X J 12 4,00000000 2,77777778 3,06250000 2,98347107 3,00444444 2,99881023 3,00031888 2,99991456 3,00002289 2,99999387 3,00000164 2,99999956 3,00000012
2,00000000 1,66666667 1,75000000 1,72727273 1,73333333 1,73170732 1,73214286 1,73202614 1,73205742 1,73204904 1,73205128 1,73205068 1,73205084
Le programme permettant de raliser ce calcul sera:

Program RacineCarree Var Xj, Xj1, Erreur, N: Double; {On travaille en double prcision} Begin Write('Donnez le nombre: '); Readln(N); Xj := N/2.0; {Comme approximation de dpart, on prend la moiti de N} Erreur := 1; {Valeur suprieure celle du test pour parcourir le boucle au moins une fois} While Erreur > 1.0e-5 Do {On demande une prcision du cent millime} Begin XJ1 := (Xj + N)/(Xj + 1); {Calcul de l'itration suivante} Erreur := Abs((Xj1-Xj)/Xj1); {Calcul de l'erreur relative} Writeln('Racine = ',Xj1,' Erreur = ',Erreur); {Affichage chaque Xj := Xj1; itration pour contrle} End; End;
D.VIESLET
8 -9 Rv. 443
Exercice 33 La racine carre (WHILE) La racine carre d'un nombre N se calcule galement au moyen de la formule X
j 1=
X j2 N 2 X j
Ecrivez le programme qui utilise cette formule et qui affiche le rsultat quand la prcision est du cent millime. Exercice 34 La racine n-ime (WHILE) La racine n-ime d'un nombre N se calcule moyen de la formule n 1 X j N X j 1= n1 n X j Ecrivez le programme qui utilise cette formule et qui affiche le rsultat quand la prcision est du cent millime.
n
8.3 La structure REPEAT ... UNTIL

Cette boucle effectue les instructions places entre deux bornes ( REPEAT et UNTIL) et value chaque rptition une condition de type boolenne avant de continuer la boucle pour dcider l'arrt ou la continuit de la rptition. Tant que cette condition est fausse, l'instruction ou squence d'instruction est rpte. Quand cette condition est vraie, l'excution du programme se poursuit l'instruction qui suit le UNTIL. L'instruction REPEAT ... UNTIL contient une expression dont l'valuation, rpte en fin de boucle permet de contrler le nombre d'excutions de la squence d'instruction dpendant de la construction REPEAT ... UNTIL. Etant donn que le test se fait en fin de boucle, les instructions comprises dans la boucle sont excutes au moins une fois. Il est ncessaire qu'au moins une instruction de la boucle modifie une variable utilise dans la condition de manire vrifier celle-ci et donc sortir de la boucle. La syntaxe est la suivante:
Repeat Instruction1; Instruction2; ... InstructionN; Until condition;
Les instructions comprises entre le REPEAT et le UNTIL sont excutes tant que la condition est fausse. Quand la condition est vrifie, la boucle se termine et l'excution se poursuit l'instruction que suit le UNTIL. Les instructions excuter un certain nombre de fois ne doivent pas ncessairement tre entoures par un BEGIN END. Le REPEAT ... UNITL encadre les instructions rpter. Toutefois l'utilisation du BEGIN END ne provoque pas une erreur. Cette boucle est toujours excute au moins une fois (car l'valuation de la condition se fait en fin de boucle). Il faut s'assurer que la condition devient vraie aprs un nombre fini d'itrations pour viter une boucle infinie. 8 -10 Rv. 443 Principes et mthodes de programmation Les structures itratives D.VIESLET
Exemples: Afficher les nombres de 1 20

Program RepeatUntil1; Var i: Integer; Begin i := 0; Repeat i := i+1; Writeln('Boucle itre ',i,' fois.'); Until i > 20; End.
Introduire un nombre positif

Program RepeatUntil2; {ce programme introduit l'instruction Repeat ... Until} Var n: Integer; Begin Repeat Write('Donnez un entier positif: '); Readln(n); Until n > 0; Writeln('Merci pour ',n); End.
A priori, nous ne savons pas quand la boucle va s'arrter. Ds lors, l'instruction FOR ... DO ne peut pas tre utilise dans ce cas. Introduire un nombre compris entre 0 et 100.000
Program DEMOREP1; Var NBRE: Real; Begin Repeat Write('Entrez un nombre de 0 100.000: '); Reanln(NBRE); Until (NBRE>=0) AND (NBRE<= 100000); Writeln('Le nombre introduit est: ,NBRE:8:2); End.
Attention! Comme dans toutes les boucles, il faut veiller viter les boucles infinies:
n := 10; Repeat n := n + 1; Until n < 0;
La variable n est initialise 10 et est incrmente dans la boucle. Elle ne deviendra donc jamais ngative et le programme bouclera indfiniment.
D.VIESLET
8 -11 Rv. 443
Exercice 35 Le nombre mystrieux But: Le but du jeu est d'inviter l'utilisateur deviner un nombre que l'ordinateur aurait "devin" (en ralit, il s'agit d'un nombre alatoire dtermin part l'ordinateur). Principe: dans un premier temps, le chiffre est choisi alatoirement entre deux bornes (valeur minimale et maximale du nombre alatoire). Ensuite, l'utilisateur est amen le deviner. Pour cela, il introduit un nombre l'cran. L'ordinateur affiche Trop petit ou Trop grand suivant que le nombre a devin est respectivement soit plus petit, soit plus grand que le nombre entr... Il faut prciser que l'utilisateur dispose d'un nombre fixe de tentatives. Que ce soit l'issue de ses nombres de tentatives ou qu'il devine le nombre cach. Si le programme se termine l'issue du nombre de tentatives, le programme affiche Dommage le nombre trouver tait de .... ou si le joueur a trouv, Bravo, vous avez trouv en ... essais . Utilisez la fonction RANDOM pour gnrer un nombre alatoire. Rfrez-vous l'aide du compilateur pour plus d'informations sur cette fonction. Modifiez le programme pour demander l'utilisateur si il dsire continuer. Si il tape n ou N , le jeu s'arrte. Si il tape autre lettre le jeu se poursuit. Exercice 36 Un peu de statistique Ecrire un programme qui permettra d'introduire un nombre indfini de valeurs et d'afficher, aprs traitement, le total de ces valeurs, la moyenne, le plus petit, le plus grand ainsi que le nombres de valeurs introduites. A chaque fois qu'un nombre est introduit, le programme demandera l'utilisateur Voulez-vous introduire un autre nombre [O/N] ? . En fonction de la rponse, un autre nombre sera demand ou bien les rsultats affichs. Exercice 37 La moyenne de la classe (REPEAT) Permettre aprs introduction du nombre des lves, d'introduire la note d'examen de chaque lve sur 100.


le nombre d'checs (rsultat infrieur 60) le nombre d'lves ayant obtenu une satisfaction (rsultat compris entre 60 inclus et 70 exclus) le nombre d'lves ayant obtenu une distinction (rsultat compris entre 70 inclus et 80 exclus) le nombre d'lves ayant obtenu une grande distinction (rsultat compris entre 80 inclus et 90 exclus) le nombre d'lves ayant obtenu la plus grande distinction (rsultat suprieur ou gal 90)
8 -12 Rv. 443
D.VIESLET
Exercice 38 Les toiles en ligne (REPEAT) Le programme demande un nombre l'utilisateur. Celui-ci doit tre compris entre 1 et 24. Si ce n'est pas le cas, afficher le message d'erreur Valeur errone. Au revoir. et quitter le programme. Si c'est le cas, afficher une ligne comportant ce nombre d'toiles ( * ). Exemples d'excution: Donnez un nombre ? 100 Valeur errone. Au revoir. Donnez un nombre ? 14 ************** Exercice 39 Les toiles en triangle (REPEAT) Le programme demande un nombre l'utilisateur. Celui-ci doit tre compris entre 1 et 24. Si ce n'est pas le cas, afficher le message d'erreur Valeur errone. Au revoir. et quitter le programme. Si c'est le cas, afficher ce nombre de lignes. Chaque ligne devra contenir un nombre croissant d'toiles ( * )allant de 1 au nombre spcifi. Exemples d'excution: Donnez un nombre ? 100 Valeur errone. Au revoir. Donnez un nombre ? 3 * ** *** Exercice 40 La factorielle (REPEAT) Ecrire un programme qui calcule et affiche la factorielle d'un nombre donn par l'utilisateur. Exemples d'excution: Donnez un nombre ? 4 La factorielle de 4 vaut 24 Exercice 41 Le nombre premier (REPEAT) Ecrire un programme affiche si le nombre donn par l'utilisateur est premier ou non. Exemples d'excution: Donnez un nombre ? 4 4 n'est pas un nombre premier.
D.VIESLET
8 -13 Rv. 443
Exercice 42 La racine carre (REPEAT) La racine carre d'un nombre N se calcule moyen de la formule X
j 1=
X j2 N 2 X j
Ecrivez le programme qui utilise cette formule et qui affiche le rsultat quand la prcision est du cent millime. Exercice 43 La racine n-ime (REPEAT) La racine n-ime d'un nombre N se calcule moyen de la formule n 1 X j N X j 1= n1 n X j Ecrivez le programme qui utilise cette formule et qui affiche le rsultat quand la prcision est du cent millime.
n
8 -14 Rv. 443
D.VIESLET
9 Les variables: deuxime partie

9.1 Introduction
Dans le langage Pascal, il est possible de dfinir de nouveaux types de variables (propres au programmeur). La notion de type va donc permettre de catgorier les donnes traites ce qui implique une scurit accrue pour le programmeur (moins d'erreurs de programmation), une reprsentation et un traitement plus agrable et plus "naturel" de ces mmes donnes. Il n'y a en effet rien de plus difficile et horrible comprendre que des programmes o par exemple le nombre 2 possde plusieurs significations diffrentes: le deuxime jour de la semaine, la deuxime coordonne du point (x,y), le deuxime lment de l'ensemble truc ... Le programmeur va pouvoir construire lui-mme ses types et ses structures d'information en utilisant les types prdfinis et les constructeurs de types que nous allons voir dans les paragraphes suivants. Il est ncessaire de dclarer ces nouveaux types dans le programme. Cette dclaration peut se faire soit directement dans la section VAR ou bien, dans une nouvelle section, la section TYPE. Celle-ci est place juste avant la rubrique VAR, elle doit commencer par le mot rserv TYPE.
Program EXEMPLE; Uses ....; Const ...............; Type ...........; Var ..............; Begin ........; ........; End.
9.2 Les types simples

Ces nouveaux types de variables peuvent tre des scalaires (propres au programmeur). On parle de types scalaires dfinis par l'utilisateur ou encore types scalaires dclars. Ces nouveaux types peuvent prendre deux formes diffrentes:

Un ensemble ordonn de valeurs dfinies par numration. Un intervalle de type scalaire prdfini (entier ou caractre) ou dclar.
9.2.1 Le type numr

Le programmeur spcifie lui-mme l'ensemble des valeurs appartenant au type qu'il dfinit. Ces valeurs constituent une liste ordonne et finie que le programmeur doit indiquer dans la partie du programme rserve aux dclarations. Cette liste tant ordonne et finie, il s'agit donc d'un type scalaire. Lors de la dclaration d'un type numr, on indique entre parenthses toutes les valeurs possibles constituant ce type.
D.VIESLET
Principes et mthodes de programmation Les variables: deuxime partie
9 -1 Rv. 443
Dclaration:
Type TypeEnumere = (Val1, Val2, Val3, ... ValN);

TypeEnumere est le nom du type numr Val1, Val2, Val3, ... ValN sont les diffrentes valeurs constituant ce type.
Var NomEnumere = (Val1, Val2, Val3, ... ValN);
Ou encore en dclarant directement une variable NomEnumere est le nom de la variable du type numr Val1, Val2, Val3, ... ValN sont les diffrentes valeurs constituant ce type.
Si nous voulons, dans un programme, utiliser de manire rpte les jours de la semaine, nous pourrions dfinir des variables du type entier et leur attribuer les valeurs de 1 7. Mais le langage Pascal nous permet de manipuler ces informations en leur attribuant les noms voulus, de lundi dimanche, ou de janvier dcembre si nous voulons manipuler des mois. Voici un exemple qui numre les jours de la semaine:
Var JJ: (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
La liste entre parenthses est un ensemble ordonn et fini d'lments. La variable JourJ peut prendre l'une des valeurs numres. Ici, le type n'est pas dfini, il est directement dclar dans la rubrique VAR. La dclaration ci-dessus est quivalente la suivante:
Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Var JJ: jour;
Cette fois, la dclaration de type est faite dans la rubrique TYPE. Le type dfini porte un nom qui est jour et la variable JourJ est de type jour. Voici comment dfinir un type numr dont les valeurs sont les quatre saisons:
Type saisons=(printemps, ete, automne, hiver); Var periode: saisons;
Le type saisons est dclar l'aide du mot rserv type. Ds ce moment, il peut figurer dans des dclarations ultrieures, au mme titre qu'un type prdfini. Voici d'autres exemples de types dfinis par numration:
Program TypeEnum0; Type fruits=(pommes, poires, ananas, peches, amandes); langages=(Basic, Pascal, Cobol, C, Java); carte=(as, roi, dame, valet, dix, neuf, huit, sept); etatcivil=(celibataire, marie, veuf, divorce); couleurs=(rouge, orange, jaune, vert, bleu, indigo, violet); Var dessert: fruits; programmeur: langages; Begin ... dessert := amandes; If programmeur = Pascal Then ...; ... End.
9 -2 Rv. 443
D.VIESLET
Proprits des types numrs A chaque valeur de la liste est associe une valeur numrique croissante. Les valeurs d'un type numr sont donc ordonnes en fonction de l'ordre dans lequel elles apparaissent lors de la dclaration, la premire valeur portant le numro d'ordre zro. Dans l'exemple suivant, lundi (numro d'ordre 0) est avant mardi (numro d'ordre 1) qui est lui-mme avent mercredi (numro d'ordre 2) etc....
Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche);
Il est ds lors possible d'appliquer les oprateurs de comparaison <,=,>, <=,>=,<> n'importe quel couple de valeurs de la liste. On peut obtenir des expressions logiques (dont le rsultat est boolen). Exemple: les jours d'ouverture ou de fermeture d'un bureau, on pourra crire:
If aujourdhui < samedi Then Write('OUVERT') Else Write('FERME');
Comme pour tous les types scalaires , les valeurs des types numrs sont ordonnes et dnombrables, ce qui rend possible l'utilisation des fonctions prdfinies:

PRED correspond l'lment prcdant celui choisi dans la liste. SUCC correspond l'lment suivant celui choisi dans la liste. ORD retourne le numro d'ordre de l'lment choisi dans la liste en commenant par 0 pour le 1er lment.
Toujours dans le mme exemple, SUCC(lundi) retourne mardi, PRED(samedi) retourne vendredi, ORD(lundi) retourne 0, ORD(dimanche) retourne 6 et SUCC(dimanche) tout comme PRED(lundi) gnrent une erreur. La fonction ORD(valeur) retourne la place de la valeur dans l'numration. Il existe pour tout type numr une fonction rciproque qui accepte comme argument le numro d'ordre et retourne la valeur de l'numration se trouvant cette place. Cette fonction rciproque porte le nom du type. Toujours en partant du mme exemple: jour(3) retourne jeudi; jour(0) retourne lundi. L'argument peut tre le rsultat d'une opration. Une variable d'un type numr est un scalaire et peut donc tre utilise comme variable de contrle dans une boucle FOR .. DO, comme constante de comparaison d'un CASE ... OF ou comme indice d'un tableau:
Program TypeEnum1; Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Var JourJ: Jour; Begin For JourJ := lundi To vendredi Do Begin Case JourJ Of lundi: Writeln('Lundi'); mardi: Writeln('Mardi'); End; End; End.
D.VIESLET
9 -3 Rv. 443
Exemple: On veut afficher les jours d'ouverture et de fermeture d'un bureau. (On se contentera de reprsenter chaque jour par son rang).
Program TypeEnum3; Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Var JourJ: jour; Begin For JourJ := lundi To dimanche Do Begin Write(ord(JourJ)); If JourJ < samedi Then Writeln(' ouvert') Else Writeln(' ferm'); End; End.
Exemple: Utilisation des fonctions pred et succ

Program TypeEnum2; Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Var aujourdhui: jour; Begin aujourdhui := jeudi; { fonction PRED } If pred(aujourdhui) > lundi Then Writeln ('ok') {dans ce cas, pred(aujourdhui} est mercredi et la condition est vrifie} Else Writeln('non'); { fonction SUCC } If succ(aujourdhui) > samedi Then Writeln('ok') {dans ce cas, succ(aujourdhui} est vendredi et la condition n'est pas vrifie} Else Writeln('non'); { fonction Ord } aujourdhui := MERCREDI; Writeln(ord(aujourdhui)); Writeln(ord(succ(aujourdhui))); Writeln(ord(pred(pred(aujourdhui))));
{affiche 2} {affiche 3} {affiche 0}
For aujourdhui := lundi To dimanche Do Write(ord(aujourdhui), ' ' ); {cette boucle affiche les nombres de 0 6} Writeln; End. { On passe une ligne }
9 -4 Rv. 443
D.VIESLET
Exemple:
Program TypeEnum4; Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Var jour: journee; i: Integer; Begin For journee := lundi To dimanche Do Begin i:=(ord(journee)); Case i of 0:Write('Lundi '); 1:Write('Mardi '); 2:Write('Mercredi '); 3:Write('Jeudi '); 4:Write('Vendredi '); 5:Write('Samedi '); Else Write('Dimanche '); End; If journee<samedi Then Writeln (' Else Writeln(' ferm'); End; End. ouvert')
Remarques Ne pas confondre les valeurs lundi, mardi,... de l'exemple avec les chanes de caractres 'lundi' , 'mardi', ... Dans notre exemple, demander le prdcesseur de lundi ou le successeur de dimanche provoquera une erreur (out of range). Restrictions portant sur les types numrs La lecture et l'affichage des valeurs figurant dans un type numr ne sont pas autoriss; il ne s'agit pas de chanes de caractres. Exemple:
Program TypeEnum5 Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Var aujourdhui: jour; jouranniv: String; numerojour: Integer; Begin aujourdhui := lundi; // Write(aujourdhui); // jouranniv := aujourdhui; // numerojour := ord(aujourdhui);// Reanln(aujourdhui); // End. Permis Interdit Interdit Permis Interdit
D.VIESLET
9 -5 Rv. 443
Cependant plusieurs compilateurs fournissent cette extension, comme par exemple Pascal Macintosh et Pascal VAX. Un valeur d'un type numr ne peut tre un mot rserv. Si vous voulez utiliser un type numr pour les notes de musique de la manire suivante:
Type NoteMusique = (do, re, mi, fa, sol, la, si);
Cela ne sera pas accept par le compilateur car do est un mot rserv. Utilisez plutt l'ancien nom de la note: ut .
Type NoteMusique = (ut, re, mi, fa, sol, la, si);
Une mme valeur ne peut pas figurer dans deux types numrs diffrents. Si vous voulez crer une application utilisant tous les jours de la semaine ainsi que les jours de la semaine de travail, vous pourriez vouloir dclarer deux types de cette manire:
Type joursem=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); jourtravail=(lundi, mardi, mercredi, jeudi, vendredi); jourrepos=(samedi,dimanche);
Cela n'est pas accept par le langage Pascal, car des valeurs sont communes aux deux types. Une constante n'est pas un identificateur. Il n'est donc pas permis de dclarer:
Type impair = (1, 3, 5, 7, 9, 11); Type voyelle = ('a', 'e', 'i', 'o', 'u', 'y');
Aucune opration arithmtique ne peut tre effectue sur des valeurs de ce type. Exemple:
Program mauvais; Type voyelle = (a, e, i, o, u, y); Var v1, v2: voyelle; Begin v1 v1 v2 v2 := := := := 1+3+5; // Interdit a; // Autoris v1+1; // Interdit voyelle(ord(v1)+1); //Autoris
End.
Dans le code ci-dessus, remarquez l'absence d'apostrophes dans l'numration des valeurs du type voyelle: a est un identificateur; 'a' est une constante de type caractre. Le nombre maximum d'lments est de 255.
9.2.2 Le type intervalle

Les variables dclares avec un type scalaire donn peuvent prendre uniquement des valeurs correspondant ce type. Mais il est frquent d'utiliser seulement un sous-ensemble de ces valeurs possibles. Dans ce cas, on pourrait restreindre cet ensemble de valeurs l'intervalle qui nous intresse.
9 -6 Rv. 443
D.VIESLET
Le langage Pascal permet cette restriction en faisant appel au type intervalle, qui n'est pas un type au sens strict, mais un sous-ensemble de valeurs prises dans un type de base. Ce type de base peut tre un type scalaire quelconque (dfini ou dclar). Ce type est dfini comme un intervalle de valeurs appartenant l'un des types de base suivants:

entier; caractre; numr pralablement dfini.
et dlimit par deux bornes (une borne infrieure et une borne suprieure). Dclaration:
Type TypeIntervalle = BorneInf .. BorneSup;

TypeIntervalle est le nom du type intervalle dfini ici BorneInf et BorneSup sont les limites infrieure et suprieure de l'intervalle.
Var NomIntervalle = BorneInf .. BorneSup;
Ou encore en dclarant directement une variable NomIntervalle est le nom de la variable du type intervalle BorneInf et BorneSup sont les limites infrieure et suprieure de l'intervalle.
L'ordre des lments dans l'intervalle est dfini par l'ordre de ses lments ( les codes ASCII pour les caractres, l'ordre numrique pour les entiers ou l'ordre de dfinition pour le type numr). Exemples:
Type Minuscules = 'a' .. 'z'; {Minuscule est un type intervalle de caractres. Seuls les caractres compris entre a et z peuvent tre affects une variable de type minuscules.)
Units = 0 .. 9;
{Units est un type intervalle d'entiers pouvant prendre des valeurs allant de 0 9.}
Mois = (janvier, fevrier, mars, avril, mai, juin, juillet, aout, septembre, octobre, novembre, decembre);{mois est un type numr} Ete = juillet .. septembre; {Ete est un type intervalle driv du type numr mois}
Guerre_Mondiale = 1940..1944; {Guerre_mondiale est un type intervalle d'entiers. Les variables de ce type pourront prendre uniquement des valeurs entires comprises entre 1940 et 1944} Jour = (lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); Jourtravail = lundi .. vendredi; Var Lettre: Minuscules; Nombre: Unites; Vacance: Ete; Annee: Guerre_Mondiale;
D.VIESLET
9 -7 Rv. 443
Les bornes de l'intervalle sont incluses dans l'ensemble des valeurs possibles. Le type intervalle est essentiellement utilis dans deux buts.

pour amliorer la lisibilit et la comprhension pour augmenter la fiabilit des programmes, car le langage Pascal dtecte si une variable reoit une valeur hors de l'intervalle dclar.
Le type numr sert souvent de type de base au type intervalle. Voici un exemple qui l'illustre:
Type jours=(lundi, mardi, mercredi, jeudi,vendredi, samedi, dimanche); weekend=samedi..dimanche; Var aujourdhui: jours; conge: weekend; travail: lundi .. vendredi;
Le type correspondant un type intervalle est celui des lments qui servent le dfinir. Comme pour tous les types scalaires , les valeurs des types numrs sont ordonnes et dnombrables, ce qui rend possible l'utilisation des fonctions prdfinies ORD, PRED et SUCC. Le type de base d'un type intervalle doit tre un scalaire. Il n'est donc pas permis de dfinir un type intervalle sur des nombres rels. Le type intervalle peut donc tre utilise comme variable de contrle dans une boucle FOR ... DO, comme constante de comparaison d'un CASE ... OF ou comme indice d'un tableau. Les oprations et fonctions applicables une variable intervalle sont les mmes que celles qui s'appliquent au type associ, partir duquel ce type est dfini. L'utilisation du type intervalle entre dans le cadre de la discipline que le programmeur s'impose pour faciliter une intervention ultrieure sur son programme.
9.3 Les types structurs

Les types structurs combinent des lments prdfinis (entiers, rels, caractres ou boolens) suivant une structure. Le rsultat de cette combinaison est un ensemble de donnes soit de mme type (chanes de caractres, tableaux) soit de types diffrents (enregistrements, fichiers).
9.3.1 Le type tableau

Un tableau est compos d'un nombre fixe d'lments de mme type appel type de base. Il est dfini par les bornes d'indice et par le type de ses lments. On peut placer nimporte quel type de variables dans un tableau except les fichiers. Les bornes d'indice doivent tre d'un type scalaire. Un tableau est donc une collection de valeurs et est dclar par la syntaxe ARRAY [...] OF dans la partie dclarative du programme. La dclaration d'un tableau de fait de la manire suivante:
Type TypeTableau: Array[IndMin..IndMax] of TypeDonnees;

TypeTableau est le nom du type tableau, IndMin et IndMax sont les indices minimum et maximum. Ces valeurs doivent tre d'un type scalaire. Il s'agit en fait d'un type intervalle.
9 -8 Rv. 443
D.VIESLET
TypeDonnees est le type des lments. Il peut s'agir de n'importe quel type except les fichiers
Var NomTableau: Array[IndMin..IndMax] of TypeDonnees;
Ou aussi en dclarant directement une variable NomTableau est le nom de la variable tableau, IndMin et IndMax sont les indices minimum et maximum. Ces valeurs doivent tre d'un type scalaire. Il s'agit en fait d'un type intervalle. IndMin doit tre infrieur IndMax TypeDonnees est le type des lments. Il peut s'agir de n'importe quel type except les fichiers Il n'existe pas de constante d'un type tableau. Il n'existe pas d'opration sur les tableaux hormis l'affectation. Il n'y a pas de fonction (mme prdfinie) rsultat d'un type tableau. Il n'y a pas d'entres-sorties sur les tableaux.
Le type tableau comporte toutefois certaines restrictions:

Une fois le tableau dclar, on peut accder ses diffrents lments en utilisant loprateur d'indice [ ] (les crochets) prcd du nom du tableau. Exemple: dclaration dun tableau de cinq entiers se fait comme suit:
Var MonTableau: Array[0..4] Of Integer;
Pour accder aux lments de ce tableau:

MonTableau[0] MonTableau[1] MonTableau[2] MonTableau[3] MonTableau[4] := := := := := 3; 5; 7; MonTableau[1] * 4; MonTableau[0] * MonTableau[2];
Les indices, dans ce cas, doivent tre des entiers. La syntaxe de Pascal exige que l'indice soit plac entre crochets T[4]. Ne pas utiliser un indice hors limite; dans cet exemple T[5]. Cela provoque une erreur l'excution. Le tableau doit-tre dimensionn ds la dclaration. C'est--dire que l'on doit connatre le nombre maximum d'lments. Les oprations autorises sur les lments d'un tableau sont celles du type des lments. Donc partout o une variable d'un type simple donn peut tre utilise, un lment de tableau de ce type peut l'tre galement. Exemple: dclaration d'un tableau de 20 chanes de caractres:
Var TabCh: Array[1..20] Of String;
Le nombre dlments du tableau est dtermin lors de la compilation ainsi que les valeurs minimum et maximum de ses indices. Il est possible de dclarer un tableau de onze entiers comme suit:
Var MonTableau: Array[10..20] Of Integer;
Les lments du tableau seront numrots de 10 20 et donc les indices devront tre compris entre ces deux valeurs incluses.
D.VIESLET
9 -9 Rv. 443
Les lments du tableau peuvent tre initialiss lors de la dclaration de celui-ci:

Var MonTableau: Array[0..4] Of Integer = (3,2,5,6,4);
L'affectation se fait de manire habituelle entre tableaux strictement de mme type et de mme taille:
premiere_table := seconde_table;
Voici un programme qui demande l'utilisateur d'introduire les cinq entiers constituant un tableau et qui en calcule la somme:
Program TabEx1; Var Somme,Compteur: Integer; Tableau: Array[1..5] Of Integer; Begin For Compteur := 1 TO 5 Do { Introduction des valeurs du tableau } Begin Write(' Entrez le nombre ',Compteur,': '); Readln(Tableau[Compteur]); End; somme := 0; { Calcul et affichage de la somme } For Compteur := 1 To 5 Do Somme := Somme + Tableau[Compteur]; Writeln('La somme des cinq lments vaut: ', Somme); End.
Le programme suivant calcule le nombre de lettres minuscules diffrentes contenues dans un texte introduit par l'utilisateur.
Program TabEx2; Type cptcar = Array['a'..'z'] of Integer; {L'indice du tableau est un scalaire de type intervalle de caractres} Var compteur: cptcar;{Tableau contenant le nombre de chaque caractre} ligne: String; {Chane de caractres analyser} c: Char; {Caractre prenant successivement la valeur de chaque caractre de la chane} i: Integer; {Variable valant de 1 la longueur de la chane} Begin For c := 'a' To 'z' Do compteur[c] := 0; {Remise 0 des compteurs} Writeln('Entrez votre texte en tapant une ligne vide pour finir'); Repeat Readln(ligne); If Length(ligne) > 0 Then Begin For i := 1 To Length(ligne) Do Begin c := ligne[i]; If(c >= 'a') and (c <= 'z') Then compteur[c] := compteur[c] + 1; End; {Termine le bloc d'instructions du For} End; {Termine le bloc d'instructions du If } Until Length(ligne) = 0; Writeln('Votre texte comporte:');
9 -10 Rv. 443
D.VIESLET
For c := 'a' To 'z' Do If compteur[c] > 0 Then Writeln(compteur[c],' fois la lettre ',c); End.
Exemple d'utilisation de type numr comme indice:

Type jour=(lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche); gain_jour = Array[jour] of Real; Var recettes: gain_jour;
La variable recettes est un tableau de 7 lments rels, reprs par l'un des identificateurs lundi, mardi, mercredi, jeudi, vendredi, samedi, dimanche. Exemple d'utilisation de type numr comme indice:
Type couleur_base = (rouge, vert, bleu); couleur = Array[couleur_base] of Integer; Var point: couleur;
La variable point est un tableau de 3 lments entiers reprs par l'un des identificateurs rouge, vert, bleu. Cette variable point pourrait contenir une couleur comme tant la combinaison des trois couleurs de base Exemple de tableau de type enumr:
Type couleur_base = (rouge, vert, bleu); ligne = Array[1..100] of couleur_base; Var trait: ligne;
La variable trait est un tableau de 100 lments de type couleurbase, reprs par un entier. Cette variable trait pourrait reprsenter une succession de 100 points colors, ayant chacun l'une des trois couleurs de base. Exemple gnral:
Type notemus = (ut,re,mi,fa,sol,la,si); melodie = Array[1 .. 1000] of notemus; Var doudou,frerejacques: melodie; nbnote: Array[ut..si] of Integer; i: Integer; n: notemus;
Exercice 44 Le minimum et le maximum Demandez l'utilisateur d'introduire 10 nombres rels que vous stockerez dans un tableau. Dterminez et affichez ensuite les valeurs minimum et maximum ainsi que leurs indices. Affichez par exemple Le minimum vaut 4,37 et est en position 4 . Exercice 45 Les valeurs uniques Dclarez un tableau de 6 entiers. Remplissez ensuite ce tableau avec des valeurs alatoires allant de 0 9 mais en vous assurant qu'un chiffre n'est jamais rpt. Affichez ensuite le rsultat.
D.VIESLET
9 -11 Rv. 443
Exercice 46 Le lotto Ecrivez un programme qui affecte des valeurs alatoires entires comprises entre 1 et 42 (inclus) un tableau de 6 entiers. Assurez-vous qu'une valeur n'est jamais rpte. Affichez ce tableau. Triez-le par ordre croissant et affichez-le nouveau. Exercice 47 Le jeu de ds Demandez l'utilisateur d'introduire les valeurs rsultant de 10 jets de d. Ces valeurs doivent tre comprises entre 1 et 6. Si l'utilisateur introduit une valeur errone, affichez un message d'erreur et redemandez-lui cette valeur. Stockez ces valeurs dans un tableau. Calculez et affichez ensuite le nombre de fois que chacune des valeurs de 1 6 est sortie. Exercice 48 Le tableau dans tous les sens Ecrivez un programme qui demande l'utilisateur d'introduire 10 nombres entiers que vous stockerez dans un tableau. Affichez le texte Tableau original et ensuite les lments de ce tableau sur une ligne. Permutez ensuite les lments dans le tableau: l'lment 1 prend la valeur du 10 et vice-versa; le 2 du 9; le 3 du 8,.... Affichez le texte Tableau permut et le tableau sur une ligne. Triez le tableau par ordre croissant de valeurs en utilisant le tri bulles. Affichez le texte Tableau tri et le tableau sur une ligne. Modifiez la procdure en utilisant le tri bulles amlior. Rappel: pour permuter les lments d'un tableau, vous aurez besoin d'une variable intermdiaire. Exercice 49 La moyenne de la classe Permettre aprs introduction du nombre des lves (maximum 50), d'introduire la note d'examen de chaque lve sur 100. Mmoriser les diffrentes notes dans un tableau de 50 rels. Une fois le tableau rempli, le parcourir et

Calculer et afficher la moyenne de la classe. Calculer et afficher le nombre d'checs (note infrieure 60). le nombre d'checs (rsultat infrieur 60) le nombre d'lves ayant obtenu une satisfaction (rsultat compris entre 60 inclus et 70 exclus) le nombre d'lves ayant obtenu une distinction (rsultat compris entre 70 inclus et 80 exclus) le nombre d'lves ayant obtenu une grande distinction (rsultat compris entre 80 inclus et 90 exclus) le nombre d'lves ayant obtenu la plus grande distinction (rsultat suprieur ou gal 90)
Modifiez le programme de manire afficher

9 -12 Rv. 443
D.VIESLET
Exercice 50 Les deux tableaux Demandez l'utilisateur d'introduire 2 tableaux de 4 rels. Calculez et affichez le tableau qui est la somme de ceux-ci. Calculez et affichez le produit cartsien de ceux-ci. Un tableau peut galement tre multidimensionnel. Les tableaux vus jusqu' prsent sont appels unidimensionnels car ils permettent de reprsenter un objet une dimension, comme par exemple un vecteur. Or le type des lments d'un tableau peut tre lui-mme un tableau et ainsi de suite. On parle alors de tableau multidimensionnel. Il est par exemple possible de reprsenter des matrices grce des tableaux 2 dimensions. Un tableau 3 dimensions peut tre utilis pour reprsenter des coordonnes dans l'espace. Les tableaux plus de trois dimensions sont utiliss pour reprsenter des concepts mathmatiques plus labors. Dclaration
Type TypeTableau1Dim: TypeTableau2Dim: TypeTableau3Dim: TypeTableau4Dim: .......

Array[IndMin1..IndMax1] Array[IndMin2..IndMax2] Array[IndMin3..IndMax3] Array[IndMin4..IndMax4]
of of of of
TypeDonnees; TypeTableau1Dim; TypeTableau2Dim; TypeTableau3Dim;
TypeTableau1Dim est le nom du type tableau 1 dimension, IndMin1 et IndMax1 sont les indices minimum et maximum. Ces valeurs doivent tre d'un type scalaire. Il s'agit en fait d'un type intervalle. TypeTableau2Dim est le nom du type tableau 2 dimensions, IndMin2 et IndMax2 sont les indices minimum et maximum. Ces valeurs doivent tre d'un type scalaire. Il s'agit en fait d'un type intervalle. TypeTableau3Dim est le nom du type tableau 3 dimensions, IndMin3 et IndMax3 sont les indices minimum et maximum. Ces valeurs doivent tre d'un type scalaire. Il s'agit en fait d'un type intervalle. TypeTableau4Dim est le nom du type tableau 4 dimensions, IndMin4 et IndMax4 sont les indices minimum et maximum. Ces valeurs doivent tre d'un type scalaire. Il s'agit en fait d'un type intervalle. Et ainsi de suite avec des tableaux de dimension 5, 6,..... TypeDonnees est le type des lments. Il peut s'agir de n'importe quel type except les fichiers
Type TypeTableau: Array[IndMin1..IndMax1,IndMin2..IndMax2,...] of TypeDonnees;
Une autre syntaxe possible pour la dclaration de tableaux multidimensionnels:
NomTableau est le nom du type tableau n dimensions, IndMin1, IndMax1, IndMin2, IndMax2, .... sont les indices minimum et maximum de chaque dimension. TypeDonnees est le type des lments.
D.VIESLET
9 -13 Rv. 443
Dans lexemple qui suit, on dclare un tableau deux dimensions contenant 3 * 5 entiers.
Var MonTableau: Array[0..2, 0..4] Of Integer;
On peut accder aux diffrents lments du tableau en donnant les deux indices; le premier pouvant prendre des valeurs de 0 2 et le second de 0 4. Deux syntaxes sont possibles:
X := MonTableau[1][1] + MonTableau[1][2]; X := MonTableau[1, 1] + MonTableau[1, 2];
Ces deux lignes de code sont quivalentes. Ou encore pour affecter une valeur un lment du tableau:
MonTableau[2][3] := 5; MonTableau[2, 3] := 5;
Ces deux lignes de code sont quivalentes. On peut reprsenter ce tableau comme suit: MonTableau[1,1] MonTableau[2,1] MonTableau[3,1] MonTableau[4,1] MonTableau[5,1] MonTableau[1,2] MonTableau[2,2] MonTableau[3,2] MonTableau[4,2] MonTableau[5,2] MonTableau[1,3] MonTableau[2,3] MonTableau[3,3] MonTableau[4,3] MonTableau[5,3]
L'affectation d'une valeur un lment du tableau se fait en prcisant les index dans les diffrentes dimensions:
MonTableau[IndexX,IndexY,....] := Valeur;
Ou encore
MonTableau[IndexX][IndexY],... := Valeur;
Les indices des diffrentes dimensions peuvent tre de type diffrent mais toujours scalaires. Exemple:
Type rangee = Array[1..10] of Integer; table = Array['a'..'z'] of rangee; Var comptage, cumul: table;
Le type range correspond un tableau de 10 lments entiers reprs par des entiers allant de 1 10. Le type table correspond 26 lments de type range, reprs chacun par une des lettres de 'a' 'z'. Le tableau comporte 26 tableaux reprs par les lettres 'a' 'z', comportant chacun 10 lments entiers reprs par un nombre de 1 10. Soit en tout 260 lments entiers, rpartis dans un tableau deux dimensions. L'affectation se fait de manire habituelle entre tableaux strictement de mme type et de mme taille. 9 -14 Rv. 443 Principes et mthodes de programmation Les variables: deuxime partie D.VIESLET
Par exemple:
premiere_table := seconde_table;
L'exemple suivant montre l'utilisation d'une matrice

Program prgTab_04; Const NBR = 3; Type tabmat = Array[1..NBR, 1..NBR] of Integer; Var note: tabmat; i,j: Integer; Begin Writeln('SAISIE DES NOMBRES'); For i := 1 To NBR Do For j := 1 To NBR Do Begin Write('NOMBRE [ ',i,',',j,']: '); Readln(note[i,j]); End; Writeln('AFFICHAGE DES NOMBRES'); For i := 1 To NBR Do Begin For j := 1 To NBR Do Write(note[i,j]:5); Writeln; End; End.
D.VIESLET
9 -15 Rv. 443
L'exemple suivant demande l'utilisateur d'introduire des notes pour 3 classes de 5 lves et affiche ensuite les tudiants qui ont obtenu plus que la moyenne.
Program prgTab_03; Const NBCL = 3; NBEL = 5; Type tabeleve = Array[1..NBCL] of Real; tabclasse = Array[1..NBEL] of tabeleve;
Var note: tabclasse; i,j: Integer; moy: Real; Begin moy := 0.0; Writeln('SAISIE DES NOTES'); For j := 1 To NBCL Do Begin For i :=1 To NBEL Do Begin Write('CLASSE ',i,' ELEVE ',j,': '); Readln(note[i][j]); moy := moy + note[i][j]; End; End; moy := moy/(NBCL * NBEL); Writeln; Writeln('RECAPITULATIF'); Writeln; Writeln('MOYENNE GENERALE: ",moy:5:2); Writeln('LISTE DES ELEVES QUI ONT OBTENU PLUS QUE LA MOYENNE"); For i := 1 To NBCL Do Begin Writeln('POUR LA CLASSE N:',i); For j := 1 To NBEL Do Begin If(note[i][j]>moy) Then Writeln('ELEVE N',j,':',note[i][j]:5:2); End; End; End.
Exercice 51 Le tableau alatoire Ecrivez un programme qui demande l'utilisateur le nombre de lignes et de colonnes d'un tableau avec un maximum de 20. Vrifiez les valeurs donnes et redemandez tant qu'elles sont errones. Remplissez ce tableau de nombres alatoires allant de 0 100. Calculez et affichez ensuite la moyenne, le minimum et le maximum de ces valeurs. Utilisez la fonction RANDOM pour gnrer un nombre alatoire. Rfrez-vous l'aide du compilateur pour plus d'informations. Vous aurez besoin de deux variables de comptage: l'une pour les lignes l'autre pour les colonnes.
9 -16 Rv. 443
D.VIESLET
Exercice 52 Le d Crez un tableau d'entiers de 10 lignes et 12 colonnes. Affectez chaque lment un nombre alatoire allant 1 6. Affichez ce tableau en lignes et colonnes. Crez un tableau de 10 rels et affectez-y la moyenne de chaque ligne. Affichez ces moyennes. Crez un tableau de 6 entiers. Affectez-y le nombre de fois que chacune des valeurs de 1 6 est prsente dans le premier tableau. Affichez ce rsultat. Exercice 53 Le dterminant Demandez l'utilisateur d'introduire les 9 lments rels d'une matrice 3*3. Calculez et affichez le dterminant de cette matrice. Exercice 54 Le systme d'quations Soit le systme d'quations a11 * x1 + a12 * x2 + a13 * x3 = y1 a21 * x1 + a22 * x2 + a23 * x3 = y2 a31 * x1 + a32 * x2 + a33 * x3 = y3 Demandez l'utilisateur d'introduire les 9 coefficients aIJ que vous stockez dans un tableau 2 dimensions ainsi que les 3 termes indpendants y1, y2 et y3 que vous stockerez dans un tableau une dimension. Rsolvez le systme d'quations par la mthode de Cramer et affichez les rsultats x1, x2 et x3.
9.3.2 Le type chane de caractres

Comme nous l'avons vu au point 3.6.1 Le type chane de caractres il est possible de dfinir des variables de type chanes de n caractres. Il est possible de redfinir un nouveau type de variable correspondant cette chane partielle. Dclaration
Type NomType = String[n];
Exemple 1:
Type { Dclaration de nouveaux types } CARAC25 = String[25]; CARAC10 = String[10]; Var { Dclaration des variables correspondant ces types } NOM,PRENOM: CARAC25; TELEPHONE: CARAC10;
Exemple 1:
Const lgmax = 30; Type chainecourte = String[15]; chainelongue = String[lgmax]; Var mota: chainecourte; nomb: chainelongue;
D.VIESLET
9 -17 Rv. 443
Une chane de caractres peut tre considre comme un tableau de caractres une dimension et il est possible de rfrencer individuellement chacun des caractres. L'indice de se tableau va de 0 la longueur de la chane. L'lment d'indice zro contient une variable de type Char dont le rang dans la table ASCII correspond la longueur de la chane (raison de la limite 255 caractres). L'lment d'indice 1 est de type Char et correspond au premier caractre de la chane, 2 le deuxime et ainsi de suite. Exemple: soit la chane S ayant pour valeur 'ABCDEF'; S[1] vaut 'A'; S[2] vaut 'B';.... Exemples de programme utilisant des chanes de caractres:
Program chaine1; Var S: String[6]; I: Integer; Begin S := 'AZERTY'; For i := 1 To 6 Do Writeln(S[i]); S[2] := 'X'; { Remplace le 'Z' par un 'X' } Writeln(S); S[0] := chr(4); { Fixe la longueur de la chane 4 caractres } Writeln(S); End.
Exemple:
Program chaine2; Var chaine: String[20]; c: Char; i: Integer; Begin Write('Donnez un mot: '); Readln(chaine); For i := 1 To Length(chaine) Do Begin c := chaine[i]; Writeln('caractre ', i:2,': ' , c); End; End.
9 -18 Rv. 443
D.VIESLET
Exemple:
Program Chaine3; Var chaine: String[20]; Begin Write('Donnez un mot: '); Readln(chaine); Writeln('chaine introduite: ',chaine); Writeln('Longueur de la chaine: ', ord (chaine[0])); End.
Risques dans l'utilisation des lments d'une variable de type chane: il est possible d'craser une zone mmoire qui n'est pas destine la chane avec les instructions de modification de caractre comme nous venons de le voir. Par contre, en utilisant la fonction COPY(), Pascal grera les accs. Une grande prudence s'impose donc. Exercice 55 Le mot l'envers Demander l'utilisateur d'introduire un mot. Rcrivez ensuite cet mot l'envers. Exercice 56 Une phrase Demander l'utilisateur d'introduire une ou plusieurs phrases. Comptez et affichez le nombre de mots et le nombre de caractres (lettres). Rcrivez ensuite cette phrase mais en inversant l'ordre des mots c'est--dire en commenant par le dernier ensuite l'avant dernier,... sans la ponctuation. Pour compter le nombre de mots, reprez les espaces mais aussi la ponctuation (virgule, deux points, points virgules) et les apostrophes. Pour compter le nombre de caractres, ignorez les espaces, la ponctuation et les caractres; mais prenez en compte les caractres accentus. Exercice 57 Une autre phrase Demandez l'utilisateur d'introduire une phrase. Assurez-vous qu'elle commence par une majuscule et qu'elle se termine par un point. Si ce n'est pas le cas, affichez un message d'erreur et demandez de recommencer. Comptez et affichez le nombre de mots et le nombre de caractres. Pour compter le nombre de mots, reprez les espaces mais aussi la ponctuation (virgule, deux points, points virgules) et les apostrophes. Pour compter le nombre de caractres, ignorez les espaces, la ponctuation et les caractres; mais prenez en compte les caractres accentus.
9.3.3 Le type ensemble

Les ensembles en pascal sont les mmes que ceux que vous connaissez en mathmatique. Un ensemble contient un nombre fini et non ordonn d'lments de mme type scalaire. Celui-ci est appel type de base. La dclaration d'une telle variable se fait par l'utilisation de la syntaxe SET ... OF.
D.VIESLET
9 -19 Rv. 443
Syntaxes:
Type NomTypeEnum = (Element1, Element2, ...); NomTypeEnsemble = Set Of NomTypeEnum;
NomTypeEnum est le type de base partir duquel est driv le type ensemble. Il doit tre un scalaire soit prdfini (entier, caractre) ou pralablement dfini par le programmeur (numr, intervalle). NomTypeEnsemble est le nom du type ensemble
Type NomTypeEnsemble = Set Of (Element1, Element2, ...);
Peut s'crire de faon plus consense NomTypeEnsemble est le nom du type ensemble
Var NomEnsemble Set Of NomTypeEnsemble;

Ou en dclarant directement une variable NomEnsemble est l'identificateur d'une variable de type ensemble. NomTypeEnsemble est le nom du type ensemble
De faon plus condense

Var NomEnsemble = Set Of (Element1, Element2, ...);
NomEnsemble est l'identificateur d'une variable de type ensemble.

Type EnsCar Set Of Char; {Dclaration d'un ensemble pouvant contenir n'importe quel caractres}
Exemple 1:
Exemple 2:
Type EnsChiffre Set Of ('0'..'9'); {Dclaration d'un ensemble de pouvant contenir les caractre allant de '0' '9'}
Exemple 3:
Type FRUIT = (pomme,poire,raisin,prune,banane); {Dclaration d'un type numr} DESSERT = Set Of FRUIT; {Dclaration du type ensemble bas sur ce type} PLATEAU: DESSERT; {Dclaration d'une variable du type ensemble}
Var
Dans ces dclarations, FRUIT est le type de base dfini par numration, DESSERT est le nom du type ensemble dfini par FRUIT. La variable PLATEAU peut tre n'importe quelle combinaison de fruits prise dans l'ensemble de base, comme par exemple:
PLATEAU := [pomme,raisin];
ou un intervalle
PLATEAU := [pomme .. raisin];
La combinaison affecte la variable peut ne contenir qu'un seul lment (singleton) ou mme aucun lment (ensemble vide [ ] ). Autre exemple en dclarant le type lors de la dclaration de la variable.
9 -20 Rv. 443
D.VIESLET
Var hasard : Set Of Byte;
Ici, la variable hasard est un ensemble de nombres entiers et dont les valeurs possibles sont dans l'intervalle 0..255. Autre exemple
Type LETTRE = Set Of 'A'..'Z'; Var MOT: LETTRE;
Ou
Var MOT: Set Of 'A'..'Z';
Dans ce cas, l'ensemble de base est dfini sur le type caractre, c'est l'ensemble des lettres majuscules de l'alphabet. La variable mot peut tre n'importe quelle combinaison de ces lettres, sans rptition et sans aucune ide d'ordre ni de sens. Les ensembles de sont pas ordonns. Donc il n'existe pas d'ordre d'apparition des lments dans une variable ensemble. On peut juste comparer le contenu de deux ensembles de mme type, et de dterminer si un lment est inclus ou non dans un ensemble. De plus, un mme lment n'apparat qu'une seule fois dans un ensemble. Et il n'existe pas de fonction qui renvoie le nombre d'lments. Par opposition au type tableau, on ne peut accder aux lments individuels d'une variable de type ensemble. L'affectation d'une combinaison concerne l'ensemble des lments. On peut toutefois demander si un lment appartient l'ensemble de la variable (oprateur IN dfini ci-aprs). Il n'existe pas de fonctions (mme prdfinies) rsultat d'un type ensemble et aucune entre-sortie n'est possible pour un ensemble. Certains compilateurs Pascal imposent une limite quant la taille maximale des ensembles. Si elle existe cette limite est gnralement petite! Par exemple la limite est de 256 pour Pascal VAX ou TURBO Pascal. Il n'y a pas de limite pour Pascal Macintosh. Notons pour les puristes qu'une "constante" de type ensemble comme [1, 2, i, j] s'appelle en fait un agrgat. Aprs avoir vu l'aspect dclaratif des ensembles, on va apprendre utiliser dans un programme des variables "ensemble". L'ensemble, quelque soit son type peut tre un ensemble nul. Pour donner une valeur un ensemble, c'est--dire, spcifier le ou les lments que devra contenir l'ensemble, on utilise l'oprateur habituel d'affectation := . Ce qu'il y a de nouveau, c'est que le ou les lments doivent tre spars par des virgules , (comme dans la dclaration du type) et tre entre crochets [ ] (contrairement la dclaration). Syntaxes:
ensemble := []; {ensemble vide } ensemble := [elem]; {ensemble constitu de l'lment elem } ensemble := [elem5,elem1]; {ensemble constitu de elem5 et eleml }
Rappel: l'ordre des lments dans une affection ou une comparaison n'a aucune importance puisque les ensembles ne sont pas ordonns. Note: une affectation un ensemble en supprime les lments qu'il contenait avant l'affectation. D.VIESLET Principes et mthodes de programmation Les variables: deuxime partie 9 -21 Rv. 443
Les oprateurs portant sur ce type de variables sont ceux dfinis au point 5.8 Oprateurs d'ensembles Si en cours de programme, on souhaite ajouter ou supprimer un ou des lments l'ensemble, on doit utiliser les oprateurs d'addition + et de soustraction - traditionnels. Syntaxes:
ensemble := ensemble + []; {inutile car n'ajoute rien !} ensemble := ensemble + [elem4]; {ajoute l'lment elem4 l'ensemble } ensemble := ensemble + [elem3,elem2]; {ajoute les lments elem3 et elem2} ensemble := ensemble + [elem1] - [elem2,elem5]; {ajoute l'lment elem1 et supprime elem2 et elem5}
Pour tre exact, les lments entre crochets reprsentent des ensembles part entire. Ces ensembles sont de mme type que la variable ensemble auquel on ajoute ou supprime des sous-ensembles. Cela s'explique par le fait que l'on ne peut additionner que des variables de mme type: on ne peut pas additionner lments et ensemble, mais par contre on peut additionner entre eux des ensembles. Ainsi un lment entre crochet est un ensemble et plusieurs lments spars par des virgules et entre crochets est aussi un ensemble. Pour employer le vocabulaire mathmatique appropri, + est l'oprateur d'union, - est l'oprateur de complment et on peut en ajouter un troisime: * est l'oprateur d'intersection. Exercice 58 Les ensembles Considrons trois ensembles de caractres: X := ['A','B','C'] Y:=['D','B',C'] et Z:=['C','D'] Calculez les expressions suivantes X+Y X >= Y XX Z <= Y Z+X+Y Y+Z XY Y=Z ZY X <> Y
Par opposition aux types scalaires, le type ensemble n'implique aucune relation d'ordre dans la combinaison affecte la variable. On peut donc crire ['A','B','C'] = ['B','C','A']. Le test d'appartenance est une construction trs utilise en relation avec les ensembles. Au moyen de l'oprateur IN le programmeur peut savoir si une valeur (du type de base) appartient ou non un ensemble. Cet oprateur a la mme priorit que les oprateurs de comparaison. Exemple:
Program DEMOENS1; Type LETTRE = Set Of 'A' .. 'Z'; { ensemble des lettres majuscules} Var LIST1,LIST2: LETTRE; CAR: Char; Begin list1 := ['A','B',' C,'D','E']; list2 := ['D','E','F','G'];
9 -22 Rv. 443
D.VIESLET
Writeln('Liste 1 = A B C D E F'); Writeln('Liste 2 = D E F G' ); Write('Donner une lettre: '); Readln(car); Write('La lettre ',car) If car In list2 Then Writeln(' appartient la liste 2 ') Else Writeln(' n''appartient pas la liste 2'); If car In lis12 Then Writeln(' appartient la liste 1 ') Else Writeln(' n''appartient pas la list1'); End.
La ligne
If car in list2 Then
est quivalente
If (car='D') or (car='E') or (car='F') or (car='G') Then
Mais l'criture est d'autant plus condense et lisible plus que le nombre d'lments est important. Exemple utilisant des oprateurs d'ensemble:
Program DEMOENS2; Type LETTRE = Set Of 'A' .. 'Z';
Var LIST1,LIST2: LETTRE; CAR: Char; Begin list1 := [ 'A','B','C','D','E']; list2 := ['D', 'E', 'F' , 'G' ]; Writeln('list1 = A B C D E '); Writeln('list2 = D E F G'); Write('Entrez une lettre:'); Readln(car); Write('La lettre ',car) If car in LIST1-LIST2 Then Writeln(' appartient exclusivement LIST1') Else If car in LIST2-LIST1 Then Writeln(' appartient exclusivement LIST2' Else If car in list1*list2 Then Writeln(' est commune LIST1 et LIST2') Else Writeln(car,' n''appartient ni LIST1 ni LIST2 '); End.
Le programme ci-aprs compte le nombre de consonnes et voyelles d'un mot:

Program DEMOENS3; Type LETTRE = Set Of 'A' .. 'Z';
D.VIESLET
9 -23 Rv. 443
Var Voyelles,Consonnes: LETTRE; Mot: String; NbVoyelles,NbConsonnes,Compteur: Integer; Begin Voyelles:=[ 'A','E','I','O','U','Y']; Consonnes:=['A' .. 'Z']-Voyelles; NbVoyelles:=0; NbConsonnes:=0; Write('Ecrivez une phrase en majuscules:'); Readln(Mot); For Compteur:=1 To Length(Mot) Do Begin If Mot[Compteur] In Consonnes Then NbConsonnes:=NbConsonnes+1; Else If Mot[Compteur] In Voyelles Then NbVoyelles:=NbVoyelles+1; End; Writeln(Mot,' contient ',NbVoyelles,' voyelles et ', NbConsonnes,'Consonnes.'); End.
Exercice 59 Le numro de tlphone Demandez l'utilisateur d'introduire des numros de tlphone. A chaque caractre tap, vrifiez qu'il s'agit bien d'un chiffre, de la barre oblique / ou d'un point . . Si c'est le cas, ajoutez le caractre une chane. L'utilisateur termine en appuyant sur la touche retour chariot . Affichez ensuite le numro introduit. Utilisez une variable de type ensemble reprenant la liste des caractres licites.
Exercice 60 Le nombre hexadcimal Demandez l'utilisateur d'introduire un nombre hexadcimal. A chaque caractre tap, vrifiez qu'il s'agit bien d'un chiffre hexadcimal c'est--dire d'un chiffre dcimal ou d'une lettre comprise entre 'A' et 'F'. Acceptez galement les minuscules. L'utilisateur termine en appuyant sur la touche retour chariot . Affichez ensuite le nombre introduit et sa conversion en dcimal. Exercice 61 Les voyelles et les consonnes Demandez l'utilisateur d'introduire un mot. Comptez le nombre de voyelles et de consonnes en considrant quivalentes les majuscules, minuscules et les caractres accentus.
9 -24 Rv. 443
D.VIESLET
9.3.4 Le type enregistrement

Les types tableau et ensemble permettent de traiter des donnes composes de plusieurs lments tous de mme type. Or d'autres donnes sont formes d'lments de types diffrents comme par exemple:

des dates chronologiques (anne, mois, jour) des fiches bibliographiques (titre du livre, auteur, date de parution, ISBN, ...) des fiches personnelles (nom, prnom, ge, sexe, taille, ) des fiches d'articles (libell, quantit, EAN,...) des donnes comptables (numro de facture, de client, date de facture, ) ..
La nature diffrente de ces lments conduit le programmeur utiliser un type de variable permettant la dfinition explicite de chacun de ces lments: les enregistrements. Un enregistrement (appel aussi structure dans certains langages) reprsente un ensemble de donnes htrognes. Chaque lment est appel un champ. La dclaration d'un type enregistrement spcifie le nom et le type de chaque champ. Celui-ci peut tre simple ou structur. La dclaration de type enregistrement a la syntaxe suivante:
Type TypeEnregistrement = record ListeChamp1: Type1; ListeChamp2: Type2; ... ListeChampN: TypeN; End;

TypeEnregistrement est un l'identificateur de l'enregistrement. ListeChampN est un identificateur valide ou une liste d'identificateurs dlimite par des virgules. Le point-virgule final est facultatif. TypeN est le type de chacun des champs.
Var NomEnregistrement = record ListeChamp1: Type1; ListeChamp2: Type2; ... ListeChampN: TypeN; End;
Ou en dclarant directement une variable:
NomEnregistrement est un l'identificateur de la variable de type enregistrement. ListeChampN est un identificateur valide ou une liste d'identificateurs dlimite par des virgules. Le point-virgule final est facultatif. TypeN est le type de chacun des champs.
Les champs sont placs dans un bloc RECORD ... END. Le type de chaque champ peut tre n'importe quel type simple ou structur except le type fichier.
D.VIESLET
9 -25 Rv. 443
La porte d'un nom de champ est limite l'enregistrement dans lequel il est spcifi. Il peut donc y avoir une variable portant le mme nom (identificateur) qu'un champ. De mme, deux champs peuvent porter le mme nom dans deux enregistrements diffrents. Il n'existe pas de constante d'un type enregistrement. Il n'existe pas d'opration autre que l'affectation sur les enregistrements. Les seules expressions d'un type enregistrement sont les variables de ce type. Il n'y a pas de fonction rsultat d'un type enregistrement. A la diffrence d'un tableau, les composantes d'un enregistrement ne sont pas accessibles par un indice. Pour les dsigner, on utilise une notation pointe qui consiste crire le nom de la variable enregistrement suivi d'un point . et du nom du champ correspondant.
NomEnregistrement.Champ1; NomEnregistrement.Champ2; ...... NomEnregistrement.ChampN;
Il n'y a pas d'opration d'entre sortie portant sur des enregistrements. Il est donc impossible d'afficher directement leur contenu. Il est ncessaire de spcifier le nom le champs dont on veut afficher la valeur. Exemple d'utilisation d'enregistrement: la dclaration suivante cre un type enregistrement nomm TDateRec .
Type TDateRec = record Annee: Integer; Mois: (Jan, Fev, Mar, Avr, Mai, Jun, Jul, Aou, Sep, Oct, Nov, Dec); Jour: 1..31; End;
Chaque TDateRec contient trois champs:

une valeur entire appele Annee , une valeur d'un type numr appel Mois une valeur entire comprise entre 1 et 31 appele Jour .
Les identificateurs Annee , Mois et Jour sont des noms de champs de TDateRec qui se comportent comme des variables. Nanmoins, la dclaration de type TDateRec n'alloue pas de mmoire pour les champs Anne, Mois et Jour. La mmoire est alloue quand vous crez la variable de type enregistrement de la manire suivante:
Var Record1, Record2: TdateRec;
Cette dclaration de variable cre deux instances de TDateRec, appeles Record1 et Record2. Vous pouvez accder aux champs de l'enregistrement en qualifiant le nom de champ avec le nom de l'enregistrement:
Record1.Annee := 1904; Record1.Mois := Jun; Record1.Jour := 16;
Le type enregistrement est frquemment associ aux fichiers. Nanmoins, ce n'est pas l une rgle gnrale: il existe des variables de type enregistrement n'ayant pas 9 -26 Rv. 443 Principes et mthodes de programmation Les variables: deuxime partie D.VIESLET
de rapport avec des fichiers et il existe des fichiers ne faisant pas appel un type enregistrement. C'est pour cette raison que nous vous proposons d'tudier ici la notion d'enregistrement indpendamment de la notion de fichier. Comme les tableaux, les enregistrements pourront tre manipuls soit globalement, soit lment par lment. Il est possible de copier les valeurs des champs de Record1 dans Record2:
Record2 := Record1;
Une autre manire de procder mais plus fastidieuse est de recopier chaque valeur:
Record2.Annee := Record1.Annee; Record2.Mois := Record1.Mois; Record2.Jour := Record1.Jour;
Au lieu de dfinir des types d'enregistrement, il est possible d'utiliser directement la construction RECORD. dans des dclarations de variable. Pour dclarer un enregistrement reprenant le nom, le prnom et l'ge d'un tudiant, on peut utiliser:
Var Etudiant: record Nom: String[30]; Prenom: String[20]; Age: Integer; End;
Cette dclaration n'est en gnral pas recommande car des enregistrements dclars sparment avec cette mthode ne sont pas compatibles pour l'affectation mme si leur structure est identique. Le code source ci-aprs provoquera une erreur lors de la compilation:
Var {Dclaration d'une premire variable} Etudiant1: record Nom: String[30]; Prenom: String[20]; Age: Integer; End; {Dclaration d'une seconde variable de structure identique} Etudiant2: record Nom: String[30]; Prenom: String[20]; Age: Integer; End; Begin Etudiant1 := Etudiant2; { IMPOSSIBLE } End.
Alors que le code suivant fonctionne parfaitement:
D.VIESLET
9 -27 Rv. 443
Type Etudiant: record {Dclaration du type Etudiant} Nom: String[30]; Prenom: String[20]; Age: Integer; End; Var Etudiant1, Etudiant2: Etudiant; {Dclaration de deux variables du mme type} Begin Etudiant1 := Etudiant2; { O.K. } End.
Dans l'exemple suivant, on regroupe les donnes d'un tudiant: nom, prnom, sexe, ge et moyenne. Le type de chacune de ces donnes est:

STRING[30] pour le nom; STRING[20] pour le prnom; CHAR pour le sexe; Intervalle 17..99 pour l'ge REAL pour la moyenne
Type Etudiant = Record { Dclaration du type enregistrement } nom: String[30]; prenom: String[20]; sexe: Char; age: 17..99; moyenne: Real; End; Var eleve: Etudiant; { Dclaration d'une variable de ce type }
La dclaration d'un tel enregistrement se fera comme suit:
L'accs aux champs de cet enregistrement se fera de la manire suivante:

eleve.nom := 'Dutruc'; eleve.prenom := 'Pol'; eleve.sexe := 'M'; eleve.age := 25; eleve.moyenne := 75.6
Voici un programme utilisant ce type enregistrement et qui demande l'utilisateur les diffrentes informations concernant l'lve et les affiche par la suite.
Program DemoEnreg1; Type Etudiant = Record { Dclaration du type enregistrement } nom: String[30]; prenom: String[20]; sexe: Char; age: 17..99; moyenne: Real; End; Var fiche: Etudiant { Dclaration de la variable }
9 -28 Rv. 443
D.VIESLET
Begin Write('Nom : Write('Prnom : Write('Sexe : Write('Age : Write('Moyenne: '); '); '); '); '); Readln(fiche.nom); Readln(fiche.prenom); Readln(fiche.sexe); Readln(fiche.age); Readln(fiche.moyenne);
Write(fiche.nom, ' '); Writeln(fiche.prenom); Write(fiche.sexe, ' '); Write(fiche.age, ' '); Writeln(fiche.moyenne); End.
Un enregistrement peut tre l'lment d'un tableau. Voici un programme qui l'illustre:
Program DemoEnreg2; const NB_ET = 15; Type Etudiant = record nom: string[30]; prenom: string[20]; sexe: Char; age: 17..99; moyenne: Real; End; Var eleve: Array[1..NB_ET] of Etudiant; i, nb: Integer; Begin Repeat Write('Combien d''tudiants (maximum 15): '); Readln(nb); Until (nb > 0) and (nb<16); For i := 1 To nb Do Begin Write('NOM Write('PRENOM Write('SEXE(m/f) Write('AGE Writeln; End; Writeln('RECAPITULATIF'); Writeln('------------------------------------------------------'); Writeln('| N |','NOM' : 15, '| ','PRENOM': 15,' | SEXE | AGE |'); Writeln('------------------------------------------------------'); For i := 1 To nb Do Begin Write('|',i:3,' |',eleve[i].nom:15,' |',eleve[i].prnom:15,' |'); If upCase(eleve[i].sexe) = 'M' Then Write('M':4) Else Write('F':4); : : : : '); '); '); '); Readln(eleve[i].nom); Readln(eleve[i].prnom); Readln(eleve[i].sexe); Readln(eleve[i].age);
D.VIESLET
9 -29 Rv. 443
Writeln(' |',eleve[i].age:4,' |'); End; Writeln ('------------------------------------------------------'); End.
Voici un autre programme qui utilise un tableau d'enregistrements ainsi que l'affectation:
Program DemoEnreg3; Const NB_PER = 5; Type Personne = Record Nom: String [30]; Prnom: String [15]; Age: 1. .150; End; Var individu: Array[1..NB_PER] of Personne; i, j: Integer; tmp: Personne; Begin Writeln('Enregistrement des individus'); Writeln; For i := 1 To NB_PER Do Begin Writeln('Employ N',i,': ' ); Write(' NOM : '); Readln(individu[i].Nom); Write(' PRENOM : '); Readln(individu[i].Prenom); Write(' AGE : '); Readln(individu[i].Age); Writeln; End; For i:=1 To NB_PER-1 Do For j:=i+1 To NB_PER Do If individu[i].nom > individu[j].nom Then Begin tmp := individu[i]; individu[i] := individu[j]; individu[j] := tmp; End; Writeln(' Writeln; INFORMATIONS TRIEES ');
For i := 1 To NB_PER Do Writeln(individu[i].nom:15,individu[i].prenom:16,individu[i].age:5); End.
Un enregistrement peut avoir pour champ un autre enregistrement et ainsi de suite. On dfinit ainsi des enregistrements d'enregistrements. Par exemple:
Type EPersonne = Record Nom, Prenom, Profession: String[25];
9 -30 Rv. 443
D.VIESLET
Age: 17.. 99; Adresse: record = Numero: 1 .. 1000; Rue: String[35]; CP: String[5]; Ville: String[25]; End; End; Var Fiche: EPersonne;
Les identificateurs Nom, Prnom, Profession, Age et Adresse permettent de reprer les diffrentes composantes de l'enregistrement EPersonne . Ils constituent les champs de la variable Fiche . On voit dans l'exemple choisi que le champ intitul Adresse est lui-mme un type RECORD, dont les champs sont: Numero , Rue , CP et Ville . Pour accder respectivement au nom et la ville, la syntaxe est
Fiche.Nom Fiche.Adresse.Ville
La dclaration peut galement se faire de la manire suivante:

Type Eville = Record Numero: 1 .. 1000; Rue: String[35]; CP: String[5]; Ville: String[25]; End; EPersonne = Record Nom, Prenom, Profession: String[25]; Age: 17.. 99; Adresse: Eville; End; Var Fiche: EPersonne;
Dans cet exemple, on dclare d'abord le type EAdresse que l'on utilise ensuite dans le type EPersonne . L'avantage de cette dclaration est que l'on peut utiliser le type EAdresse dans plusieurs autres types. Par exemple:
Type EAdresse = Record Numero: 1 .. 1000; Rue: String[35]; CP: String[5]; Ville: String[25]; End; EPersonne = Record Nom, Prenom, Profession: String[25]; Age: 17.. 99; Adresse: EAdresse; End;
D.VIESLET
9 -31 Rv. 443
ESocilete = Record Nom: String[25]; RaisonSociale: String[6]; Adresse: EAdresse; Var Fiche: EPersonne; Fournisseur: ESociete;
Exemple de programme:
Program DemoEnreg4; Type EPersonne = Record Nom, Prenom, Profess: String[25]; Age: 1... 99; Adresse: Record Numero: 1 .. 1000; Rue: String[35]; CP: String[5]; Ville: String[25]; End; End; Var Fiche: Epersonne; Begin Write('Entrez Write('Entrez Write('Entrez Write('Entrez Write('Entrez Write('Entrez Write('Entrez Write('Entrez le nom le prnom 1''ge la profession la rue le numro le Code Postal la Ville : : : : : : : : ');Readln(fiche.nom); ');Readln(fiche.prenom); ');Readln(fiche.age); ');Readln(fiche.profess); ');Readln(fiche.adresse.rue); ');Readln(fiche.adresse.numero); ');Readln(fiche.adresse.cp); ');Readln(fiche.adresse.ville);
Write(fiche.nom,' ',fiche.prenom,' Age: ',fiche.age,' ans'); Writeln(' Profession: ',fiche.profess); Writeln; Writeln(fiche.adresse.numero,' ',fiche.adresse.rue); Writeln; Writeln(fiche.adresse.cp,' ',fiche. adresse. ville); End.
Voici un autre exemple d'utilisation multiple d'un type enregistrement:

Program DemoEnreg5; Const NBPER = 5; Type EDate = Record Jour: 1..31; Mois: 1..12; Annee: 1900..2025; End; EPersonne = Record Nom: String[30]; Prenom: String[15]; DateNaissance: EDate;
9 -32 Rv. 443
D.VIESLET
DateEmbauche: Edate; End; Var Employe: Array[1 .. NBPER] Of EPrsonne; i, nbr: Integer; Begin Write('Nombre d''employs encoder (maximum ',NBPER,'): '); Readln(nbr); For i := 1 To nbr Do Begin Writeln('Employ N',i,' '); Write(' PRENOM : '); Readln(Employe[i].Prenom); Write(' NOM : '); Readln(Employe[i].Nom); Writeln(' DATE NAISSANCE'); Write(' Jour : '); Readln(Employe[i].DateNaissance.Jour); Write(' Mois : '); Readln(Employe[i].DateNaissance.Mois); Write(' Anne : '); Readln(Employe[i].DateNaissance.Annee); Writeln(' DATE EMBAUCHE'); Write(' Jour : '); Readln(Employe[i].DateEmbauche.Jour); Write(' Mois : '); Readln(Employe[i].DateEmbauche.Mois); Write(' Anne : '); Readln(Employe[i].DateEmbauche.Annee); Writeln; End; Writeln('RECAPITULATIF:'); For i:=1 To 56 Do Write('-'); Writeln; Writeln('|','PRENOM':15,'|','NOM':15,'|NAISSANCE For i:=1 To 56 Do Write('-'); Writeln;
|EMBAUCHE
|');
For i := 1 To nbr Do Begin Write('|',Employe[i].Prenom:15,'|',Employe[i].nom:15,'| '); Write(Employe[i].DateNaissance.Jour:2,'-'); Write(Employe[i].DateNaissance.mois:2,'-'); Write(Employe[i].DateNaissance.Annee:4,'|'); Write(Employe[i].DateEmbauche.jour:2,'-'); Write(Employe[i].DateEmbauche.mois:2,'-'); Write(Employe[i].DateEmbauche.Annee:4,'|'); Writeln; End; For i:=1 To 56 Do Write('-'); Writeln; End.
La manipulation des enregistrements fait apparatre un grand nombre de redondances dans le code. En effet, chaque fois que l'on veut accder un lment d'un enregistrement, il est ncessaire de rpter le nom de ce dernier.
Record1.Annee := 1904; Record1.Mois := Juin Record1.Jour := 16
Pour viter ce genre de rptition et augmenter la lisibilit, on utilise l'instruction l'instruction WITH ... DO
D.VIESLET
9 -33 Rv. 443
With Record1 Do Begin Anne := 1904; Mois := Juin; Jour := 16; End;
Grce l'instruction WITH ... DO, le compilateur prfixe par Record1 tous les identificateurs qui correspondent un nom de champ. En utilisant l'instruction WITH ... DO, le programme DemoEnreg1 devient:
Program DemoEnreg6; Type Etudiant = Record { Dclaration du type enregistrement } nom: String[30]; prenom: String[20]; sexe: Char; age: 17..99; moyenne: Real; End; Var fiche: Etudiant { Dclaration de la variable } Begin With fiche Do Begin Write('Nom : Write('Prnom : Write('Sexe : Write('Age : Write('Moyenne: ');Readln(nom); ');Readln(prenom); ');Readln(sexe); ');Readln(age); ');Readln(moyenne);
Write(nom,' '); Writeln(prenom); Write(sexe,' '); Write(age,' '); Writeln(moyenne); End; End.
En utilisant l'instruction WITH ... DO, le programme DemoEnreg4 devient:

Program DemoEnreg7; Type EPersonne = Record Nom, Prenom, Profess: String[25]; Age: 1... 99; Adresse: Record Numero: 1 .. 1000; Rue: String[35]; CP: String[5]; Ville: String[25]; End; Var Fiche: Epersonne;
9 -34 Rv. 443
D.VIESLET
Begin With fiche Do Begin Write('Entrez le nom : ');Readln(nom); Write('Entrez le prnom : ');Readln(prenom); Write('Entrez 1''ge : ');Readln(age); Write('Entrez la profession : ');Readln(profess); With adresse Do Begin Write('Entrez la rue : ');Readln(rue); Write('Entrez le numro : ');Readln(numero); Write('Entrez le Code Postal : ');Readln(cp); Write('Entrez la Ville : ');Readln(ville); End; Write(nom,' ',prenom,' Age: ',age,' ans'); Writeln(' Profession: ',profess); Writeln; With adresse Do Begin Writeln(numero,' ',rue); Writeln; Writeln(cp,' ',Ville); End; End; End.
En utilisant l'instruction WITH ... DO, le programme DemoEnreg5 devient:

Program DemoEnreg8; const NBPER =5; type EDate = Record Jour: 1..31; Mois: 1..12; Annee: 1900..2025; End; EPersonne = Record Nom: String[30]; Prenom: String[15]; DateNaissance: EDate; DateEmbauche: Edate; End; Var Employe: Array[1..NBPER] Of EPersonne; i, nbr: Integer; Begin Write('Nombre d1'employs encoder (maximum ',NBPER,' ): '); Readln(nbr); For i := 1 To nbr Do Begin With Employe[i] Do Begin Writeln('Employ N',i,' '); Write(' PRENOM : '); Readln(Prenom);
D.VIESLET
9 -35 Rv. 443
Write(' NOM : '); Readln(Nom); Writeln(' DATE NAISSANCE'); With DateNaissance Do Begin Write(' Jour : '); Readln(Jour); Write(' Mois : '); Readln(Mois); Write(' Anne : '); Readln(Annee); End; Writeln(' DATE EMBAUCHE'); With DateEmbauche Do Begin Write(' Jour : '); Readln(Jour); Write(' Mois : '); Readln(Mois); Write(' Anne : '); Readln(Annee); End; Writeln; End; End; Writeln('RECAPITULATIF:'); For i:=1 To 56 Do Write('-'); Writeln; Writeln('|','PRENOM':15,'|','NOM':15,'|NAISSANCE For i:=1 To 56 Do Write('-'); Writeln; For i := 1 To nbr Do With Employe[i] Do Begin Write('|',prnom:15,'|', nom:15,'| '); Write(DateNaissance.jour:2,'-'); DateNaissance.mois:2,'-'); DteNaissance.anne:4,'|'); Write(DateEmbauche.jour:2,'-'); DateEmbauche.Mois:2,'-'); DateEmbauche.Annee:4,'|'); End; For i:=1 To 56 Do Write('-'); Writeln; End;
|EMBAUCHE
|');
Cette instruction peut amliorer la lisibilit du code source mais peut tre aussi une source de confusion. En effet, dans l'exemple prcdent, les lignes
Write(' Write(' Write(' Jour : '); Readln(Jour); Mois : '); Readln(Mois); Anne : '); Readln(Annee);
sont rptes de manire identique mais concernent d'une part la date de naissance et d'autre part le date d'embauche. A ne pas confondre. Dans une dfinition de type enregistrement, il est possible d'avoir une partie variable: elle permet de slectionner les informations mmoriser, en fonction d'un certain critre. Selon ce critre, diffrents champs de diffrents types seront crs. La configuration de type adopte est fixe par le programme lui-mme en cours d'excution (elle est appele variante). Celle-ci dpend de la valeur d'un champ particulier de l'enregistrement, appel discriminant. Le critre de choix est spcifi l'aide d'un CASE ... OF pratiquement semblable l'instruction portant le mme nom. Le principe consiste en l'utilisation d'un type scalaire (gnralement un type numr) dont les valeurs seront les valeurs test de l'instruction CASE ... OF. Ensuite, on cre le type enregistrement de manire classique pour les champs fixes. En dernier lieu, on cre la structure conditionnelle. Celle-ci est constitue du mot rserv CASE suivi du nom d'un champ fixe d'un type scalaire dont la valeur 9 -36 Rv. 443 Principes et mthodes de programmation Les variables: deuxime partie D.VIESLET
conditionne la suite et du mot rserv OF. On procde ensuite comme pour un CASE ... OF normal: on crit les diffrents lments (par forcment tous...) du type scalaire (des constantes) suivis du symbole deux points : et entre parenthses ( ) on spcifie les champs et leur type correspondant l'lment ou aux lments. Donc suivant la valeur d'un champs fixe de type numr, on va procder la cration d'un ou plusieurs champs. Il est possible de ne crer aucun champ pour une valeur donne; il suffit de ne rien indiquer entre les parenthses. Syntaxe:
Type TypeEnumere= {Element1, Element2, ... ElementN); TypeEnregistrement=Record Champl: Typel; Champ2: Type2; ...: Case ChampX: TypeEnumere Of Element1: {Champ3:.Type3,......); Element2: {Champ4: Type4,......); ... ElementN: {......); End;
La partie variable se dclare comme dernier lment de l'enregistrement. L'instruction END finale termine aussi bien le CASE ... OF que le RECORD. Il est possible de dclarer une partie variable comme dernier lment de la dernire composante d'une partie variable. Exemple: un enregistrement reprenant les dimensions d'une forme gomtrique.
Type FORME = (TRIANGLE,RECTANGLE,TRAPEZE); DIMENS = Record Case GENRE: FORME Of TRIANGLE: (BASE,HAUTEUR: Real); RECTANGLE: (LONGUEUR,LARGEUR: Real); TRAPEZE: (GBASE,PBASE,HAUTEUR: Real); End;
Une variable de type DIMENS ne contiendra pas toujours le mme nombre d'informations. Suivant la valeur du discriminant GENRE de type FORME , les champs de l'enregistrement variable seront au nombre de deux (base et hauteur pour un triangle, longueur et largeur pour un rectangle) ou de trois (grande base, petite base et hauteur pour un trapze). Cet enregistrement ne contient pas de partie fixe. Dans le cas d'un calcul de surface, par exemple, une instruction CASE..OF dans le programme pourra slectionner la formule approprie chacune des diffrentes variantes. Aprs introduction des donnes utiles: type de forme gomtrique (carr, rectangle, triangle ou trapze), des dimensions utiles en fonction de la forme choisie (carr: ct, rectangle: longueur et largeur, triangle: base et hauteur ou trapze: grande base, petite base et hauteur), calculer et afficher la surface de la forme.
Program DEMREC5;(* Type record avec partie variable.*) Type FORME = (carre,rectangle,triangle,trapeze); DIMENS = Record Case GENRE: FORME of carre: (cote: Real); Rectangle: (longueur,largeur: Real);
D.VIESLET
9 -37 Rv. 443
End;
Triangle: (base,hauteur: Real); Trapeze: (gbase,pbase,hauteur: Real);
Var FIGURE: DIMENS; C: Char; Surf: Real; Begin Write('Entrez la forme (C/E/T/P): '); Readln(c); With FIGURE Do Begin Case C of 'C','c': GENRE := Carre; 'R','r': GENRE := Rectangle; 'T','t': GENRE := Triangle; 'P','p': GENRE := Trapeze; End; Case GENRE of carre: Begin Write('Entrez le ct: '); Readln(cote); SURF:=COTE*COTE; End; rectangle: Begin Write('Entrez la longueur : '); Readln(longueur); Write('Entrez la largeur : '); Readln(largeur); SURF:=longueur*largeur; End; triangle: Begin Write('Entrez la base : ');Readln(base); Write('Entrez la hauteur : ');Readln(hauteur); SURF:=base*hauteur/2; End; trapeze: Begin Write('Entrez la grande base :');Readln(gbase); Write('Entrez la petite base : ');Readln(pbase); Write('Entrez la hauteur : ');Readln(hauteur); SURF:=(gbase+pbase)*hauteur/2; End; End; End; Writeln('La surface est de: ',surf:6:2); End.
Exemple: une fiche bibliographique d'un livre est complte par des renseignements sur l'emprunteur lorsque celui-ci prt. Ceci illustre le cas o dans une certaine condition, aucun champ n'est cr.
9 -38 Rv. 443
D.VIESLET
Type t_annee_de_parution = 1500 .. 2099; t_fiche_biblio = Record auteur: String[30]; titre: String; annee_de_parution: t_annee_de_parution; Case prete: Boolean Of (* partie variante *) false: ( ); (* Si le livre n'est pas emprunt, on n'ajoute aucun champ *) true: ( nom_emprunteur: String[30]; jour_retour:Word;mois_retour:Word;annee_retour:Word); (* partie variante on ajoute le nom de l'emprunteur ainsi que la date de retour du livre *) End; (* fin de la partie variante et de l'enregistrement *)
L'accs aux lments de cet enregistrement se fait de manire classique:

Var manuel_pascal: t_fiche_biblio; Begin manuel_pascal.auteur := 'N. Wirth'; manuel_pascal.titre := 'Pascal'; manuel_pascal.annee_de_parution := 1971; manuel_pascal.prete := true; (* la composante existante est alors celle spcifie lorsque le champ prete vaut true *) manuel_pascal.nom_emprunteur := 'Dupont'; ... End.
Attention: il ne devrait pas tre possible d'accder des champs d'une composante non existante (mais certains compilateurs ne le vrifient pas!).
manuel_pascal.prete:=false; (*la composante variante est alors vide*) manuel_pascal.nom_emprunteur := 'Dupont'; (* ERREUR *)
Exemple: les nombres complexes sont reprsents soit en coordonnes cartsiennes: partie relle et imaginaire ou en coordonnes polaires: module et argument. Ceci illustre le cas o l'enregistrement ne contient pas de partie fixe.
Type t_representation = ( polaire, cartesienne ); t_complexe = record case mode_utilisation: t_representation of cartesienne: (partie_reelle , partie_imaginaire: Real); polaire: (module: Real , argument: Real ); End;
Exemple: la fiche d'une personne. On souhaite enregistrer le nom, le prnom et le statut marital d'une personne (mari, veuf, divorc ou clibataire). En fonction de ce statut:

S'il est mari ou veuf, date de son (dernier) mariage; S'il est divorc, la date de son (dernier) mariage et la date de son divorce; S'il est clibataire, une indication permettant de savoir s'il est isol ou non.
D.VIESLET
9 -39 Rv. 443
Type statut_marital = (marie, veuf, divorce, celibataire); date = Record jour_s: (lun, mar, mer, jeu, ven, sam, dim); jour: 1..31; mois: 1..12; annee: 1900..2100; End; personne = Record nom: String[15]; prenom: String[15]; date_naissance Case statut_martial Of marie,veuf: (date_mariage:date); divorce: (date_mariage:date;date_divorce;date); celibataire: (isole:Boolean); End;
9.3.5 Le type fichier

Le type enregistrement est fortement associ au type fichier, que nous verrons au chapitre suivant.
9 -40 Rv. 443
D.VIESLET
10 Les procdures et fonctions dfinies

10.1 Introduction
Tout le monde connat la notation mathmatique sous la forme: y = f (x) Dans cette notation, f est la fonction mathmatique, x est un paramtre ou argument pass la fonction, et y recevra le rsultat de la fonction, appel aussi la valeur de retour de la fonction. Par exemple, lorsque nous avons utilis la fonction SQRT, cette fonction accepte un argument (la valeur calculer) et retourne une valeur (la racine du nombre donn en argument), SQRT ralise un calcul (la racine carre). Nous parlerons dans ce cas d'une fonction. Par ailleurs, nous avons rgulirement utilis jusqu'ici des instructions comme WRITELN, WRITE,... Le point commun entre ces diffrents ordres est que nous n'attendons pas de rsultat de calcul. Le seul objectif sera d'afficher quelque chose l'cran. En d'autres termes, nous n'attendons pas de valeur de retour d'une telle action mais uniquement qu'une action se ralise. Nous parlerons dans ce cas de procdure. Une fonction a comme objectif de raliser un calcul. Elle accepte gnralement des arguments et possde une valeur de retour. Une procdure ralise une action (plutt qu'un calcul). Elle accepte ou non des arguments mais ne retourne rien. L'utilisation de procdures et fonctions rend le code source plus lisible, surtout lorsqu'il est ncessaire de s'y replonger longtemps aprs l'avoir crit. Ds qu'un programme atteint plus d'une page A4 de code, il devient ainsi difficilement lisible. Cela permet aussi d'viter des squences d'instructions rptitives. Si le mme traitement doit tre rpt plusieurs fois dans un mme programme, nous allons crire une fonction ou une procdure permettant de raliser ce traitement. Ce code sera appel autant de fois que ncessaire mais ne sera crit qu'une seule fois. Nous parlerons de routine quant il s'agit indiffremment d'une fonction ou d'une procdure.
10.1.1 Les procdures

Une procdure est une suite d'instructions dcrivant une action simple ou complexe, laquelle on donne un nom. Chaque fois que l'on aura besoin de faire cette action, il suffira d'voquer ce nom, au lieu d'crire plusieurs fois la suite d'instructions. La cration d'une procdure correspond donc l'extension des instructions prdfinies du langage. Le fait de n'crire qu'une seule fois la suite d'instructions en utilisant la notion de procdure procure de nombreux avantages:

conomie de place, facilit d'criture, intelligibilit des programmes, facilit de maintenance et modification du programme,
D.VIESLET
Principes et mthodes de programmation Les procdures et fonctions dfinies
10 -1 Rv. 443
programmation dite structure qui consiste dcomposer le problme en sous-problmes qui seront eux-mmes dcomposs, jusqu' atteindre un niveau de difficult lmentaire beaucoup plus facile traiter.
La dclaration et l'implmentation de la procdure se font aprs les dclarations usuelles et avant le dbut du programme (mot cl BEGIN). Pour cela, on utilise le mot cl PROCEDURE suivi du nom de la procdure. Celui-ci doit rpondre aux rgles d'criture des nonces au point 2.4.3 Les identificateurs.
10.1.2 Les fonctions

Une fonction est similaire une procdure sinon qu'elle renvoie une valeur au programme principal. Le type de cette valeur, qu'il convient de prciser dans l'entte de sa dclaration, est celui du rsultat qui lui est associ. Une fonction est une suite d'instructions dcrivant une action simple ou complexe, laquelle on donne un nom. Cette action gnre un rsultat qui sera renvoy au programme qui a appel la fonction. Chaque fois que l'on aura besoin de ce rsultat, il suffira d'voquer le nom de la fonction qui le gnre, au lieu d'crire plusieurs fois la suite d'instructions. La cration d'une fonction correspond donc l'extension des instructions prdfinies du langage. Les avantages que procurent la notion de fonction sont identiques ceux des procdures:

conomie de place, facilit d'criture, intelligibilit des programmes, facilit de maintenance et modification du programme, programmation dite structure .
La dclaration et l'implmentation de la fonction se font aprs les dclarations usuelles et avant le dbut du programme (mot cl BEGIN). Pour cela, on utilise le mot cl FUNCTION suivi du nom de la fonction. Celui-ci doit rpondre aux rgles d'criture des nonces au point 2.4.3 Les identificateurs. Le nom d'une fonction se comportant comme une variable de type simple, on ne peut utiliser la fonction que lorsque le rsultat est de type simple. (entiers, rels, caractres, chanes, boolens, intervalles ou ensembles). On invoque (appelle) une fonction en utilisant simplement son nom, suivi de la liste des paramtres effectifs si ncessaire. La valeur de retour de la fonction est donne en affectant cette valeur au nom de la fonction. Exactement comme si le nom de la fonction tait en fait le nom d'une variable. La syntaxe est la suivante pour une fonction appele Ma_fonction et une valeur retourner attribue la variable Resultat :
Resultat:= .............; {Calcul de la valeur retourner} .......... Ma_fonction:=Resultat;
Si cela n'est pas fait, aucune erreur ne sera signale la compilation mais lorsque nous appellerons la fonction, nous aurons comme rsultat une valeur non dtermine.
10 -2 Rv. 443
D.VIESLET
10.2 Les routines sans argument

10.2.1 Les procdures
Premier exemple de procdure:
Program exemple_Procedure; Var i: Integer; {Dclaration de la variable i} Procedure optimiste; {Dclaration et implmentation de la procdure} Begin Writeln('Il fait souvent beau !'); End; {Fin de l'implmentation de la procdure} Begin {Dbut du programme principal} For i := 1 To 5 Do optimiste; {5 appels conscutifs de la procdure} Writeln('.. mais pas chez nous !'); End. {Fin du programme principal}
Suivant l'en-tte du programme et les dclarations habituelles, nous trouvons ce que nous appellerons une dclaration de procdure:
Procedure optimiste; Begin Writeln(' Il fait souvent beau !'); End;
Cette dclaration dfinit la fois:
le mot rserv PROCEDURE, le nom de la procdure (son identificateur) suivi d'un point-virgule ; son action , dlimite par un BEGIN et un END.
Le programme principal va se drouler de la manire habituelle, si ce n'est qu'au sein de celui-ci, nous trouvons l'appel de la procdure. Celui-ci s'opre en invoquant la nom de la procdure:
optimiste;
10.2.2 Les fonctions

Premier exemple de fonction:
Program exemple_fonction; Var age: Integer; {Dclaration de la variable age} Function l_age: Integer;{Dclaration et implmentation de la fonction} Begin Write('Donnez votre ge: !'); Readln(age); l_age := age; End; {Fin de l'implmentation de la fonction} Begin {Dbut du programme principal} age := l_age; {appel de la fonction} Writeln('Vous avez ',age,' ans.'); End. {Fin du programme principal}
D.VIESLET
10 -3 Rv. 443
Suivant l'en-tte du programme et les dclarations habituelles, nous trouvons ce que nous appellerons une dclaration de fonction:
Function l_age: Integer;{Dclaration et implmentation de la fonction} Begin Write('Donnez votre ge: !'); Readln(lireage); End; {Fin de l'implmentation de la fonction}
Cette dclaration dfinit la fois:
le mot rserv FUNCTION, le nom de la fonction, le symbole deux points : , le type de variable renvoy par la fonction suivi d'un point-virgule ; son "action", dlimite par un BEGIN et un END.
Le retour de la valeur de la fonction au programme appelant se fait en affectant celle-ci l'identificateur de la fonction:
l_age := age;
Le programme principal va se drouler de la manire habituelle, si ce n'est qu'au sein de celui-ci, nous trouvons l'appel de la fonction. Celui-ci s'opre en invoquant la nom de la fonction et en assignant son rsultat une variable du type adquat:
i:=lireage;
10.2.3 Procdures et fonctions

Il est bien sr possible de dclarer plusieurs procdures et/ou fonctions dans un mme programme.
Program exemple_Mixte; Procedure Bonjour; {Dclaration et implmentation de la procdure} Begin Write('Bonjour '); End; {Fin de l'implmentation de la procdure} Procedure Monsieur; {Dclaration et implmentation de la procdure} Begin Bonjour; Writeln('Monsieur '); End; {Fin de l'implmentation de la procdure} Procedure JeuneHomme; {Dclaration et implmentation de la procdure} Begin Bonjour; Writeln('Jeune homme'); End; {Fin de l'implmentation de la procdure} Function l_age: Integer;{Dclaration et implmentation de la fonction} Begin Write('Donnez votre ge: !'); Readln(age); l_age:=age; End; {Fin de l'implmentation de la fonction} Begin {Dbut du programme principal} Writeln; If l_age > 20 Then Monsieur Else JeuneHomme; End. {Fin du programme principal}
10 -4 Rv. 443
D.VIESLET
10.2.4 Modification du droulement des routines

La procdure optimiste et la fonction l_age crites ci-dessus effectuent systmatiquement les mmes oprations. Il serait plus intressant que la procdure ou la fonction puisse effectuer des oprations diffrentes en fonction de certains paramtres. Pour ce faire, deux possibilits:

les variables globales, le passage d'arguments.
10.3 La porte des variables

10.3.1 Les variables globales
L'exemple suivant est sensiblement identique au prcdent concernant les procdures, si ce n'est que la valeur de la variable globale est affiche chaque appel de la procdure optimiste .
Program exemple_Procedure; Var i: Integer; Procedure optimiste; Begin Writeln(' Il fait souvent beau ', i , ' fois !'); End; Begin For i := 1 To 5 Do optimiste; Writeln(' .. mais pas chez nous ! ' ); End.
La variable i est considre comme globale car elle est connue dans tout le code du programme et des procdures que ce programme comporte ou pourrait comporter. Aucune dclaration n'a t ralise au sein de la procdure optimiste . L'exemple suivant est une fonction qui calcule le minimum de deux valeurs:
Program exemple_Fonction; Var X,Y: Integer; Function Min(A,B: Integer): Integer; Begin If A<B Then End; Begin; Write(' Entrez le premier nombre entier: ');Readln(X); Write(' Entrez le second nombre entier : ');Readln(Y); Writeln(' Le plus petit nombre entier est: ', Min(X,Y) ); End. Min :=A Else Min := B;
D.VIESLET
10 -5 Rv. 443
Dans ce programme, Min est le nom de la fonction. Il est utilis comme un identificateur de variable de type entier. Son rle est double: il identifie la fonction, ce qui permet de l'appeler, mais aussi il sert de paramtre pour le retour d'une valeur au programme appelant. Exercice 62 La saison Ecrire un programme qui demande une date l'utilisateur sous forme de trois entiers (jour, mois, anne). Ces trois variables seront dclares globalement. Ce programme appelle une procdure appele Saison qui en fonction de la date affiche la saison correspondante. Pour simplifier, on considre que les saisons printemps, t, automne hiver commencent respectivement le 21 des mois de mars, juin, septembre et dcembre. Exercice 63 Le minimum et le maximum par procdure Ecrire un programme qui utilise une procdure pour afficher le minimum et le maximum de trois nombres entiers. Ceux-ci seront demands l'utilisateur. Les 5 variables seront dclares globalement.
10.3.2 Les variables locales

Il est possible de dclarer une variable au sein d'une routine. Dans ce cas, cette nouvelle variable n'est connue qu' l'intrieur de la routine. Elle est appele pour cette raison variable locale la routine. Les valeurs de ces variables seront rinitialises chaque appel. Ainsi, une routine peut utiliser les variables globales du programme (dclares en tout dbut) mais aussi ses propres variables locales qui lui sont rserves. Une routine ne peut pas accder une variable locale appartenant une autre. On peut utiliser dans une routine, un nom pour une variable locale dj utilis pour une autre variable locale dans une autre routine. Exemple:
Program exemple_Procedure; Var c1, c2: Char; {Dclaration de deux variables globales c1 et c2} Procedure tri_car; {Dclaration et implmentation de la procdure} Var c: Char; {Dclaration d'une variable locale la procdure} Begin If c1 > c2 Then Begin c := c1; c1 := c2; c2 := c; End; End; {Fin de l'implmentation de la procdure} Begin {Dbut du programme principal} Writeln(' Donnez deux caractres:'); Readln(c1); Readln(c2); tri_car; Write('Caractre tris: ', c1, ' ', c2); End. {Fin du programme principal}
Nous dirons que la porte de la variable c est limite la procdure tri_car . 10 -6 Rv. 443 Principes et mthodes de programmation Les procdures et fonctions dfinies D.VIESLET
Si une variable globale est dclare, portant le mme nom qu'une mme variable locale, il n'y aura pas d'interfrence. Exemple:
Program exemple_Procedure1; Var c1, c2: Char; c: Char; {Dclaration d'une variable globale c} Procedure tri_car; Var c: Char; {Dclaration d'une variable locale c} Begin If c1 > c2 Then Begin c := c1; {C'est la variable locale qui est utilise} c1 := c2; c2 := c; End; End; Begin c:='X'; {C'est la variable globale qui est utilise} Write('Premier caractre: '); Readln(c1); Write('Second caractre: '); Readln(c2); tri_car; Writeln('Caractres tries: ',c1,' ', c2); Writeln('C vaut toujours : ', c); End.
Exemple:
Program exemple_Procedure2; Var A, B, C, D: Byte; Procedure essai; Var C, D: Byte; Begin C := 4; D: = 5; Writeln('Valeurs dans la procdure:'); Writeln('A = ', A, ' B = ', B, ' C = ', C, ' D = ' ,D); A := A + C; B := B + 1; End; Begin A := 2; B := 3; C := 6; D := 7; Writeln('Valeurs dans le programme principal avant l''appel '); Writeln('A = ', A, ' B = ', B, ' C = ', C,' D = ', D); essai; // Premier appel de la procdure Writeln('Valeurs dans le programme principal aprs le premier appel); Writeln('A = ', A, ' B = ', B,' C = ', C, ' D = ', D); A := A + C; B := B + A; essai; Deuxime appel de la procdure Writeln('Valeurs dans le programme principal aprs le second appel); Writeln('A = ', A, ' B = ', B, ' C = ', C,' D = ', D); End.
D.VIESLET
10 -7 Rv. 443
Exercice 64 Les variables locales et globales En vous basant sur l'exemple prcdent, dterminez ce que le programme affichera l'cran. Vrifiez votre rponse en introduisant et excutant ce code.
10.4 Les routines avec arguments

Il est possible de crer des routines (procdures ou fonctions) paramtres, c'est-dire acceptant des arguments. Ceux-ci sont des variables qui n'existent qu' l'intrieur de la routine. La dclaration de ces arguments se fait lors de la dclaration de la procdure. Lors de l'appel de la routine, les arguments donns peuvent tre des variables ou des constantes. Il existe trois manires de transmettre des arguments une routine: par valeur, par adresse ou par constante.
10.4.1 Les arguments transmis par valeur

Lorsque nous demandons d'afficher du texte l'cran (par exemple Bonjour ), nous appelons la procdure WRITELN en lui passant ce texte en argument.
Writeln('Bonjour');
Les procdures que nous crivons pourront galement accepter des arguments. La transmissions par valeur signifie que le compilateur va travailler avec des copies des arguments passs, et ne modifie donc pas aux variables d'origine. Exemple:
Program exemple_Procedure; Type note = (ut, re, mi, fa, sol, la, si); Var n1: note; i: Integer; Procedure affiche_note(n:note); Begin Case n ut : re : mi : fa : sol: la : si : End; End; Begin Writeln(' Voici les notes de la gamme:'); For n1 := ut To si Do affiche_note(n1); End. of Writeln('Do'); Writeln('Re'); Writeln('Mi'); Writeln('Fa'); Writeln('Sol'); Writeln('La'); Writeln('Si');
Dans l'exemple suivant, lors de l'appel de la procdure tri_car , nous transmettons deux valeurs de type caractre. Quel que soit le droulement de la procdure, il n'est pas possible de rcuprer les rsultats l'extrieur de la procdure. Il n'y a aucune valeur de retour de la procdure. Autrement dit, les modifications apportes l'intrieur de la procdure ne sont pas visibles l'extrieur. 10 -8 Rv. 443 Principes et mthodes de programmation Les procdures et fonctions dfinies D.VIESLET
Illustrons ce mcanisme en reprenant l'exemple de tri des caractres:

Program exemple_Procedure; Var c1, c2: Char; Procedure tri_car(a1, a2: Char); Var c: Char; Begin Writeln('Caractres reus par la procdure: ', a1,' ', a2); If a1 > a2 Then Begin c := a1; a1 := a2; a2 := c; End; Writeln('Caractres tries par la procdure: ', a1,' ', a2); End; Begin Write('Premier caractre: '); Readln(c1); Write('Second caractre: '); Readln(c2); Writeln; Writeln('Caractres avant appel de la procdure: ',c1, ' ',c2); tri_car(c1,c2); Writeln('Caractres aprs appel de la procdure: ',c1, ' ',c2); End.
Si l'utilisateur donne Z pour premier caractre et A pour la second, le programme affiche: Premier caractre: Z Second caractre: A Caractres avant appel de la procdure: Z A Caractres reus par la procdure: Z A Caractres tries par la procdure: A Z Caractres aprs appel de la procdure: Z A Pascal travaille dans ce cas avec des copies des variables c1 et c2 et les modifications qu'il effectue sur ces copies n'ont aucun impact sur les variables d'origine. Exemple de fonction:
Program exemple_Fonction; Const NMAX=10; Type ligne=Array[1..NMAX] Of Integer; Var a, b: ligne; i: Integer; sa, sb: Integer;
D.VIESLET
10 -9 Rv. 443
Function som(t: ligne): Integer; Var i: Integer; res: Integer; Begin res := 0; For i := 1 To NMAX Do res := res + t [i]; som:= res; End; Begin For i:=1 To NMAX Do Begin a[i]:=i; b[i]:=sqr(i); End; sa:=som(a); sb:=som(b); Writeln('Somme des ', NMAX, ' premiers nombres entiers : ', sa); Writeln('Somme des ', NMAX, ' premiers entiers au carre: ', sb); End.
Exercice 65 Le minimum et le maximum par fonction Ecrire un programme qui utilise deux fonctions pour dterminer le minimum et le maximum de trois nombres entiers passs en paramtre. Ceux-ci seront demands l'utilisateur Exercice 66 Comparer deux mots Ecrire un programme qui compare deux mots. Il demande les deux mots l'utilisateur, les rcrit sans rptition de lettres et en plaant les lettres par ordre alphabtique. Il affiche ensuite les caractres qui leur sont communs, et ceux qui apparaissent dans l'un mais pas dans l'autre. Utiliser le type ensemble pour mmoriser les diffrents caractres des deux mots. Crer une procdure qui accepte cet ensemble pour trier le mot et une autre pour dterminer les caractres prsents dans un seul mot. Exemple d'excution: Ecrire le premier mot en minuscule suivi de [enter] : bonjour Ecrire le second mot en minuscule suivi de [enter] : bonsoir Caractres du premier mot : bjnoru Caractres du second mot : binors Caractres communs : bonr Caractres du mot1 non dans le mot2 : ju Caractres du mot2 non dans le mot1 : is
10 -10 Rv. 443
D.VIESLET
10.4.2 Les arguments transmis par adresse

Il est parfois ncessaire de travailler avec les valeurs d'origine. Il se peut que les valeurs modifies par la routine doivent tre utilises dans le programme principal. Dans ce cas, il n'est pas intressant de travailler avec des copies (c--d travailler avec des valeurs). Nous devons travailler avec les variables d'origine pour rcuprer le rsultat dans le programme appelant. Exemple:
Program exemple_Procedure; Var c1, c2: Char; Procedure tri_car(Var a1, a2: Char); Var c: Char; Begin Writeln('Caractres reus par la procdure: ', a1, ' ', a2); If a1 > a2 Then Begin c := a1; a1 := a2; a2 := c; End; Writeln('Caractres tries par la procdure: ', a1, ' ', a2); End; Begin Write('Premier caractre: '); Readln(c1); Write('Second caractre: '); Readln(c2); Writeln; Writeln('Caractres avant appel de la procdure: ',c1, ' ',c2); tri_car(c1,c2); Writeln('Caractres aprs appel de la procdure: ',c1, ' ',c2); End.
Si l'utilisateur donne Z pour premier caractre et A pour la second, le programme affiche:

Premier caractre: Z Second caractre: A Caractres Caractres Caractres Caractres avant reus tries aprs appel de la procdure: Z A par la procdure: Z A par la procdure: A Z appel de la procdure: A Z
La seule diffrence entre ce code et celui de l'exemple prcdent est la prsence du mot-cl VAR dans la dfinition de la routine. Dans ce cas, il y transmission non pas de la valeur de la variable mais bien transmission de son adresse. C'est--dire son emplacement dans la mmoire appele son pointeur. Cette notion de pointeur sera tudie plus en dtail dans un chapitre ultrieur. Signalons que Pascal ne travaille plus dans ce cas avec des copies des variables mais avec les variables d'origine. Toute modification faite dans D.VIESLET Principes et mthodes de programmation Les procdures et fonctions dfinies 10 -11 Rv. 443
la procdure sur un paramtre pass par adresse est visible partir du programme appelant. Un exemple typique d'utilisation de ce mode de passage d'arguments est celui d'une routine qui permet la saisie de valeurs par l'utilisateur:
Program exemple_Procedure; Var n1, n2, p1, p2: String; Procedure Saisie (Var nom, var prenom: String) Begin Write('Entrez le nom : '); Readln(nom); Write('Entrez le prnom: '); Readln(prenom); End; Begin Saisie(n1, p1); Saisie(n2, p2); Writeln('Voici la premire personne: ', n1, ' ', p1); Writeln('Voici la deuxime personne: ', n2, ' ', p2); End.
Exemple:
Program exemple_Procedure; Var A, M: Integer; Procedure Truc(Var A: Integer); Begin If A<M Then A:=M; End; Begin; Write('Entrez la valeur de A: '); Readln(A); Write('Entrez la valeur de M: '); Readln(M); TRUC(A); Writeln('Au retour de truc A vaut: ',A); End.
Exercice 67 Les variables et arguments En vous basant sur l'exemple prcdent, dterminez ce que le programme affichera l'cran si l'utilisateur donne les valeurs 3 et 18. Vrifiez votre rponse en introduisant et excutant ce code.
10 -12 Rv. 443
D.VIESLET
Exemple:
Program exemple_Procedure; Var A, B, C: Integer; Procedure PROC(i, j: Integer; Var K: Integer); Begin I := I + J := J K := I + Write(I, End; Begin A := 3; B := 2; C := 7; Write(A, ' ', ' ', B, ' ', C, ' / '); PROC(A, B, C); Writeln(A, ' ', B, ' ', ' ', C); End. 1; 1; J; ' ', J, ' ',K, ' / ');
Exercice 68 Les variables et arguments En vous basant sur l'exemple prcdent, dterminez ce que le programme affichera l'cran. Vrifiez votre rponse en introduisant et excutant ce code. Exemple:
Program exemple_Procedure; Var A, B, C: Integer; Procedure SUB(D: Integer; Var E: Integer; C: Integer); Var A: Integer; Begin A := C + 1; E := A + C; C := C * 2; End; Begin Write(' Entrez la valeur de A: '); Readln(A); Write(' Entrez la valeur de B: '); Readln(B); Write(' Entrez la valeur de C: '); Readln(C); SUB(B, C, A); Writeln(A:3, B:3, C:3); End.
D.VIESLET
10 -13 Rv. 443
Exercice 69 Les variables et arguments En vous basant sur l'exemple prcdent, dterminez ce que le programme affichera l'cran si l'utilisateur donne les valeurs 4, 5 et 6. Vrifiez votre rponse en introduisant et excutant ce code. Exercice 70 Encore le minimum et le maximum Ecrire un programme qui utilise une procdure pour dterminer le minimum et le maximum de trois nombres entiers passs en paramtre. Ceux-ci seront demands l'utilisateur. Les valeurs du minimum et du maximum seront galement passes en paramtre.
10.4.3 Les arguments constants

Dans les deux premiers modes de passage d'arguments, la valeur de ceux-ci peut tre modifie dans la procdure. Dans le premier cas, cela n'a aucune influence sur la valeur des variables du programme appelant, dans le second, la modification est reporte dans le programme appelant. Il est possible d'interdire toute modification d'un argument dans la procdure pour s'assurer que la valeur utilise dans la procdure soit celle du programme appelant en faisant prcder le nom de la variable du mot-cl CONST. Exemple: la fonction suivante calcule la distance sparant deux points d'un plan. Les coordonnes de ceux-ci sont passes en paramtre la fonction qui ne peut videmment pas les modifier. On utilisera donc des arguments constants.
Program exemple_Fonction; Var XDebut, YDebut, XFin, Yfin: Real; Function distance(Const X1, Y1, X2, Y2: Real): Real; Begin distance := Sqrt(Sqr(x1-x2) + Sqr(y1-y2)); End; Begin Xdebut := 2.5; Ydebut := 3.5; Xfin := 4.56; Yfin := 5.47; Writeln('Distance = ',distance(XDebut, Ydebut, Xfin, YFin): 10: 3); End.
10.4.4 Les arguments mixtes

Il est galement possible en Pascal de transmettre des arguments une procdure en partie par valeur, en partie par adresse et en partie constants. L'exemple suivant illustre ce mcanisme o le tableau est transmis par valeur, la somme est transmise par adresse et la taille est constante.
10 -14 Rv. 443
D.VIESLET
Program exemple_Procedure; Const NMAX = 10; Type ligne = Array[1..NMAX] of Integer; Var a, b: ligne; i, sa, sb, t: Integer; Procedure som(t: ligne; Var som: Integer; Const n: Integer); Var i: Integer; Begin som := 0; For i := 1 To n Do som := som + t[i]; End; Begin t := 10 For i := 1 To t Do Begin a[i] := i; b[i] := sqr(i); End; som(a, sa, NMAX); som(b, sb, NMAX); Writeln('Somme des ', NMAX, ' premiers nombres entiers : ', sa); Writeln('Somme des ', NMAX, ' premiers entiers au carr: ', sb); End.
Choix d'un mode de passage d'arguments: Quand un programme doit recevoir un rsultat d'une procdure, il faut adopter le passage par adresse pour le paramtre correspondant. Dans le cas o le programme doit simplement fournir des donnes la procdure (et ne pas recevoir de rsultats en retour), tous les modes conviennent. D'une manire gnrale, si on veut prserver les valeurs des paramtres, il faut prendre le passage par valeur. Toutefois, ce mode s'avre parfois coteux en temps et en espace mmoire cause de l'opration de recopie (tableaux de grandes dimensions). Dans ce cas, le passage par variable est plus performant. Cependant, il ncessite une certaine prudence suite du risque de modification des donnes. Exemple: on souhaite crire une routine qui calcule les racines d'une quation du second degr y = a*x2 + b*x + c .Cette routine devra accepter trois arguments rels a , b et c . Ceux-ci ne peuvent tre modifis dans la routine ils seront donc passs en arguments constants. Il peut y avoir deux solutions. Etant donn qu'une fonction ne retourne qu'une seule valeur, on utilisera deux arguments x1 et x2 passs par adresse dans lesquels la routine placera les solutions aprs calcul. Toutefois, une quation du second degr peut me pas avoir de solutions relles. On utilisera donc une variable boolenne qui indiquera si la ou les solutions existent. Cette variable peut tre un argument pass par adresse ou la valeur de retour d'une fonction. Nous choisirons cette deuxime solution. La dclaration et l'implmentation de cette fonction sera:
D.VIESLET
10 -15 Rv. 443
Function R2D(const a,const Var RacExiste: Boolean; Delta: Real; Begin
b,const c, var x1, var x2: Real): Boolean;
Delta := b * b - 4 * a * c; If Delta < 0 Then RacExiste := False // Pas de solution relle Else If Delta = 0 Then // Les deux solutions sont confondues Begin RacExiste := True; x1 := (-b) / (2 * a); x2 := x1; End Else // Delta strictement est positif donc deux solutions distinctes Begin RacExiste := True; x1 := (-b+Sqrt(Delta)) /(2 * a); x2 := (-b-Sqrt(Delta)) /(2 * a); End; R2D := RacExiste; // Retour de la valeur End;
Dans le programme principal, l'appel de cette fonction peut de faire de la manire suivante:
Write('Donnez le coefficient de x carr: ); Readln(Val2); Write('Donnez le coefficient de x: ); Readln(Val1); Write('Donnez le coefficient du terme indpendant: ); Readln(Val0); If R2D(Val2, Val1, Val0, Rac1, Rac2) Then Begin Writeln('Les racines de l''quation sont: ',Rac1,' et ',Rac2); End Else Writeln('L''quation n''a pas de racines.');
Il faut bien sur dclarer pralablement cinq variables relles Val2 , Val1 , Val0 , Rac1 et Rac2 . Exercice 71 Les racines En vous basant sur l'exemple ci-dessus, crivez le programme complet qui demande l'utilisateur les diffrents coefficients et affiche les racines si elles existent ou un message dans le cas contraire.
10.5 Les routines imbriques ou sous-routines

Une routine, tant un sous-programme complet, peut contenir ses propres routines qui n'existent alors que dans la routine principale. Une sous-routine ne peut appeler d'autres procdures ou fonctions que si ces dernires font partie du programme principal ou de la routine qui contient la sous-routine. Une sous-routine ne peut tre appele directement partir du programme principal.
10 -16 Rv. 443
D.VIESLET
Syntaxe:
Procedure NomDeProcedure; Var variable: Type; Procedure NomDeSousProcedure; Var variable: Type; Begin {Instructions de la sous-procdure} End; Begin {Instructions de la procdure} End;
Une procdure pouvant tre dclare l'intrieur d'une autre, il en rsulte des imbrications qui peuvent conduire une confusion, si on ne respecte pas des rgles d'accs aux diffrents lments manipuls (constantes, types, variables, procdures,...). Pour chaque lment, on dfinit un niveau qui est dtermin de la manire suivante:

les lments dfinis dans le programme principal sont au niveau 0, les lments dfinis dans un lment niveau 0, sont au niveau 1, les lments dfinis dans un lment niveau 1, sont au niveau 2, ...
Program niveau; {Programme principal niveau 0} Var I, A, B: Integer; {Variables niveau 0} Procedure P1(X, Y: Integer); {Procdure niveau 1} Var I, J: Integer; {Variables niveau 1} Procedure P2(A, B: Real); {Procdure niveau 2} Var M, N: Integer; {Variables niveau 2} Begin {Instructions procdure niveau 2} End; Begin {Instructions procdure niveau 1} End; Begin {Instructions programme principal niveau 0} End.
On peut illustrer cette notion de niveau l'aide de l'exemple suivant:
N I V E A U 2
N I V E A U 1
N I V E A U 0
D.VIESLET
10 -17 Rv. 443
Explications:

Identificateurs (variables et procdures) reconnus au niveau 0: I, A, B, P1 Identificateurs reconnus au niveau 1: X, Y, I, J, P2 locaux au niveau 1 A, B, P1 globaux au niveau 0 Identificateurs reconnus au niveau 2: A, B, M ,N locaux au niveau 2 (A,B diffrents de ceux du niveau 0) X,Y,I,J,P2 locaux P1 (et donc globaux pour P2) Aucun identificateur global PP
La procdure P2 a des variables A,B qui n'ont aucun rapport avec les variables globales A,B dclares dans au niveau 0. On peut utiliser le mme nom pour des objets dclars des niveaux diffrents. P2 ne peut donc pas accder aux variables globales A,B puisqu'elle possde des variables locales portant les mmes noms. Toute variable locale au niveau 0 est globale l'ensemble des procdures du programme sauf si une procdure possde des variables locales portant le mme nom (cas de A et B dans notre exemple). Si une procdure (P2) est contenue dans une autre (P1), toute variable locale P1 est globale P2 . Si P1 et P2 sont disjointes et de mme niveau, elles peuvent s'appeler l'une l'autre. Une procdure de niveau I peut en appeler une de niveau I+1, si elle la contient. Dans l'exemple ci-dessus, l'appel de P1 partir de P3 (ligne 51) est tout fait correct, puisque pendant la compilation de P3 , la procdure P1 est connue ainsi que tous ses paramtres. En rgle gnrale, une procdure peut en appeler une autre d'un mme niveau la condition expresse que, dans la dclaration des procdures, la procdure appele soit dclare avant la procdure appelante. Ce qui explique que l'on ne peut, dans cet exemple, pas appeler P3 partir de P1 (ligne 25), tout simplement parce que P3 n'est pas connu au moment de la compilation de P1 .
10 -18 Rv. 443
D.VIESLET
Program niveau; {Programme principal niveau 0} Var A,B: Integer; {Variables niveau 0} Procedure P1; {Procdure niveau 1} Var I,J: Integer; {Variables niveau 1} Procedure P2; {Procdure niveau 2}
N I V Begin E {Instructions procdure niveau 2} A {Aucun appel de procdure possible sauf rcursivit} U {Variables connues A,B,I,J,M,N} 2
Var M,N: Integer; {Variables de niveau 2} End;
Begin {Instructions procdure niveau 1} P2; {Appel de P2 correct car P1 contient P2} P3; {Appel de P3 ERREUR P3 non encore dfini} P4; {Appel de P4 ERREUR P4 non dfini pour P1} {Variables connues A,B,I,J} End; Procedure P3; {Procdure niveau 1} Var K,L: Integer; {Variables niveau 1} Procedure P4; {Procdure niveau 2}
N I V E A U 1
N I V Begin E {Instructions procdure niveau 2} A {Aucun appel de procdure possible sauf rcursivit} U {Variables connues A,B,K,L,O,P} 2
Var O,P: Integer; {Variables niveau 2} End;
N I V E A U 0 N I V E A U 1
Begin {Instructions procdure niveau 1} P2; {Appel de P2 ERREUR P2 non dfini pour P3} P1; {Appel de P3 correct car P3 de mme niveau que P1} P4; {Appel de P4 correct car P3 contient P4} {Variables connues A,B,O,P} End; Begin {Instructions programme principal niveau 0} End.
D.VIESLET
10 -19 Rv. 443
Toutefois, il existe un moyen permettant de le faire: il suffit simplement de faire suivre l'en-tte de la procdure P1 du mot FORWARD:
Procedure P1 (paramtres de P1); Forward;
On signifie au compilateur que le bloc de P3 sera dcrit plus loin. .Cela permet de faire l'appel de P3 partir de P1 . Dans l'exemple suivant, nous avons deux procdures: la procdure tri qui ellemme contient la procdure echange . La procdure echange est appele partir de la procdure tri . L'objectif tant dans ce cas de trier les caractres introduits par l'utilisateur. Voici le code source de cet exemple:
Program procedures_imbriquees; Const lc=10; Type chaine=String[lc]; Var suite: chaine; Procedure tri(Var t: chaine); Var i,j: Integer; Procedure echange; Var c: Char; Begin c:=t[i]; t[i]:=t[j]; t[j]:=c End; {fin de la procdure change} Begin For i:=1 To length(t)-1 Do For j := i+1 To length(t) Do If t[i]>t[j] Then echange; End; {fin de la procdure tri} Begin Write('Donnez une suite d''au plus ',lc,' caractres: '); Readln(suite); tri(suite); Writeln('Voici votre suite ordonne: ', suite); End.
La procdure echange est imbrique dans la procdure tri . Ds lors, elle ne peut tre appele qu' partir de la procdure tri , et non pas partir du programme principal. Les identificateurs lc (constante), chaine (type) et suite (variable) sont dfinis dans le programme principal et sont connus de l'ensemble du code. L'identificateur t est dclar dans tri . Ds lors, il n'est pas connu du programme principal, mais bien de la procdure change. Il en est de
10 -20 Rv. 443
D.VIESLET
mme pour les variables i et j , toutes deux dclares dans tri . Enfin, l'identificateur c , dfini dans la procdure change ne sera connu que de celle-ci. La procdure tri est imbrique dans le programme principal, et la procdure echange est imbrique dans la procdure tri . Les variables dclares dans une procdure sont connues dans les sous-procdures, mais l'inverse n'est pas vrai.
10.6 La rcursivit
10.6.1 Introduction
Ce chapitre va prsenter non pas une nouvelle structure du langage Pascal mais une technique permettant l'criture d'algorithmes particuliers appels algorithmes rcursifs (cf. ci-dessous). Prcisons tout de suite que seules quelques ides gnrales seront donnes et non une thorie complte!
10.6.2 La rcursivit simple

Pour illustrer la rcursivit, prenons l'exemple du calcul de la factorielle d'un nombre entier naturel. La factorielle est est le produit des nombres entiers strictement positifs infrieurs ou gaux n. La factorielle (qui se note par un point d'exclamation) est dfinie par la formule N! = 1 * 2 * 3 * ... * (N-1) * N Elle peut galement se dfinir par la formule N! = N * (N-1)! Une telle formule est dite rcursive car le calcul de N! implique la connaissance et l'utilisation de (N-1)! qui, elle-mme, implique celles de (N-2)! qui, elle-mme, implique celles de (N-3)!, etc... Dfinition: de manire gnrale la rcursivit est le fait de dfinir un objet, une action... au moyen de cet objet, de cette action... Pascal permet qu'une procdure ou une fonction s'appelle elle-mme; une telle procdure ou fonction est appele rcursive.
D.VIESLET
10 -21 Rv. 443
Exemple de calcul de factorielle par rcursivit:

Program Factorielle; Function facto(n: Integer): Integer; Begin If n < 2 Then facto:= 1 {Condition de fin: pas d'appel rcursif} Else facto := n * facto(n - 1); {Appel rcursif de la fonction} End; Var n: Integer; Begin Writeln ('Hello'); Write('Entrez un nombre: '); Readln(n); Writeln('La factorielle de ',n,' vaut ', facto(n)); Readln; End.
La fonction facto est rcursive car elle s'appelle elle-mme. Dans chaque algorithme rcursif, il est impratif de trouver au moins une condition de fin. Ceci se fait en considrant un ou plusieurs cas o il n'y a pas d'appels rcursifs. Dans l'exemple de la factorielle, la condition est n<2. En effet, la factorielle de 1 vaut 1 et par dfinition, la factorielle de 0 vaut 1. Il n'est pas ncessaire de faire un appel rcursif dans ce cas. Pour que la condition de fin finisse par tre vrifie, l'appel rcursif doit des faire avec une valeur diffrente de l'argument. Autre exemple de rcursivit simple: la suite de Fibonacci. On dfinit une suite de nombres tels que le n ime lment de cette suite soit gal la somme des deux prcdents. On dcide que les deux premiers nombres sont 0 et 1. La suite obtenue est la suivante: 0 1 1 2 3 5 8 13 21 34 55 ... Si le nime nombre est not F(n) se calcule par la formule F(n) = F(n-1) + F(n-2) Une telle formule est dite rcursive car le calcul de F(n) implique la connaissance et l'utilisation de F(n-1) et F(n-2) qui, eux-mmes, impliquent celles de F(n-3) et F(n-4) etc. Les valeurs de F(i) sont appels nombres de Fibonacci. Pour crire une fonction qui calcule le nime nombre de Fibonacci, il faut considrer trois cas:

n = 0 la fonction donne 0 comme rsultat n = 1 la fonction donne 1 comme rsultat autre valeur de n la fonction donne F(n-1) + F(n-2) comme rsultat
10 -22 Rv. 443
D.VIESLET
On obtient donc le programme suivant:

Program Fibonacci; Function fibo(n: Integer): Integer; Begin {fibonacci} If n = 0 Then fibo := 0 {Condition de fin: pas d'appel rcursif} Else If n = 1 Then fibo := 1{Condition de fin: pas d'appel rcursif} Else fibo := fibo(n-1) + fibo(n-2); {Autres cas: appels rcursifs} End; (* fibonacci *) Var n: Integer; Begin Write('Entrez un nombre: '); Readln(n); Writeln('Le nombre ',n,' de Fibonacci vaut ', fibo(n)); End.
Exercice 72 Le nombre d'appels Modifier la fonction calculant les nombres de Fibonacci de manire compter et afficher le nombre de fois o la fonction est appele pour un calcul. Utiliser pour cela une variable globale. Exercice 73 La puissance Ecrire une fonction qui calcule la puissance entire d'un nombre rel par rcursivit. Inclure cette fonction dans un programme qui demande le nombre et la puissance l'utilisateur et qui affiche le rsultat. Se baser sur la formule suivante pour crire la fonction rcursive X n = X * X (n - 1)
Il existe une autre mthode dite dichotomique pour calculer la puissance entire d'un nombre. Elle se base sur les formules suivantes: Si n est pair X n = X (n / 2) * X (n / 2) Si n est impair X n = X (n / 2) * X (n / 2) * X L'exposant (n / 2) tant la division entire de n par 2. L'avantage de cette mthode par rapport la prcdente est que l'appel rcursif se fait avec l'argument divis par 2 et non l'argument 1. La condition de fin sera atteinte beaucoup plus rapidement. Si l'argument double, il y aura un appel rcursif supplmentaire alors que dans le premier cas, il y aura n appels supplmentaires.
D.VIESLET
10 -23 Rv. 443
La fonction pourra donc s'crire:

Function puissance(x: Real; n: Integer): Real; Var resultat: Real; {variable intermdiaire pour les calculs} Begin {puissance} If n = 0 Then resultat := 1 {Condition de fin: pas d'appel rcursif} Else If n = 1 Then resultat := x {Autre condition de fin} Else {Autres cas: appels rcursifs} Begin {Calcul intermdiaire de x exposant n divis par 2 en entier} resultat := puissance(x, n div 2); {Calcul de x exposant n divis par 2 en entier multipli par x exposant n divis par 2 en entier} resultat := resultat * resultat; {Si n est impair, il faut multiplier le rsultat prcdent par x} If (n div 2) <> 0 Then resultat := resultat * x; End; puissance := resultat; {Renvoi du rsultat des calculs} End; {puissance}
Exercice 74 La puissance par dichotomie Modifier le programme prcdent en y incluant cette fonction. Le programme principal appelle d'abord la fonction qui calcule la puissance comme prcdemment. Afficher le rsultat du calcul ainsi que le nombre de fois o cette fonction est appele. Le programme principal appelle ensuite la fonction dichotomique avec les mmes arguments et affiche le rsultat ainsi que le nombre d'appels. Comparer le nombre d'appels dans les deux cas. Exemple: le tri bulles. Le principe du tri bulles consiste consiste permuter si ncessaire les lments d'un tableau de manire amener la valeur maximum en dernire position (pour un tri croissant). Et de rpter ensuite l'opration sur un tableau de taille immdiatement infrieure. On peut donc crire une procdure rcursive qui effectue cette opration. Celle-ci aura le canevas suivant:
Begin Permutations ............ If Taille > 1 Then Tri(Taille 1); {Appel rcursif} End;
Exercice 75 Le tableau tri Ecrivez un programme qui demande l'utilisateur d'introduire 10 nombres entiers que vous stockerez dans un tableau. Affichez le texte Tableau original et ensuite les lments de ce tableau sur une ligne. Ecrivez une procdure rcursive qui trie le tableau par ordre croissant en utilisant le tri bulles. Affichez le texte Tableau tri et le tableau sur une ligne. Modifiez la procdure en utilisant le tri bulles amlior
10 -24 Rv. 443
D.VIESLET
Exemple: les tours de Hano. Voici un jeu clbre dont la simulation sur ordinateur fait appel la rcursivit. Considrons trois tours numrotes de 1 3. Sur la tour 1 sont poss des disques de manire constituer une pyramide. Le jeu consiste dplacer tous les disques de la tour 1 sur la tour 2 en utilisant la tour 3 comme intermdiaire et en respectant la rgle suivante: on ne peut dplacer qu'un seul disque la fois du sommet d'une tour que sur un disque plus grand ou sur un socle vide. Commenons par dcomposer ce problme en sous-problmes: Soit N le nombre de disques sur la tour 1. Pour dplacer N disques de la tour 1 vers la tour 2, en utilisant la tour 3 comme intermdiaire, il faut:
dplacer N - 1 disques de la tour 1 sur la 3 en utilisant la 2 comme intermdiaire dplacer le disque restant de la tour 1 sur le socle de la 2 dplacer les N - 1 disques de la tour 3 sur la 2 en utilisant la 1 comme intermdiaire.
Procedure deplacer {paramtres }; Begin {Dplacer N-1 disques sur une tour vide} deplacer(..........); {Dplacer le disque restant} Writeln('Deplacer le disque restant sur la tour vide'); {Dplacer N-1 disques sur celui qui vient d'tre dplac} deplacer(..........); End;
On obtient donc le squelette de procdure suivant:
Les paramtres de cette procdure sont les donnes ncessaires son excution, savoir:

le nombre de disques transfrer N la tour d'origine la tour intermdiaire la tour destination
D.VIESLET
10 -25 Rv. 443
On obtient, en ajoutant les paramtres:

Procedure deplacer(const N, tour_origine, tour_destination, tour_intermediaire: Integer); {Cette procdure dplace N disques depuis tour_origine sur tour_destination en utilisant tour_intermediaire comme intermdiaire} Begin {Dplacer N - 1 disques de tour_origine sur tour_intermediaire en utilisant tour_destination comme intermdiaire} deplacer(N 1, tour_origine, tour_intermediaire, tour_destination); {Dplacer le disque restant de tour_origine sur tour_destination} {On reprsente cela par l'affichage d'un message l'cran} Write('Deplacer le disque restant de la tour', tour_origine: 2); Writeln(' sur la tour', tour_destination: 2); {Dplacer N - 1 disques de tour_intermdiaire sur tour_destination} en utilisant tour_origine comme intermdiaire} deplacer(N 1, tour_intermediaire, tour_destination, tour_origine); End;
Reste trouver la condition de fin de l'algorithme rcursif: lorsqu'il n'y a plus de disques transfrer c'est--dire quand N vaut 0. On obtient, en ajoutant la condition de fin:
Procedure deplacer(const N, tour_origine, tour_destination, tour_intermediaire: Integer); {Cette procdure dplace N disques depuis tour_origine sur tour_destination en utilisant tour_intermediaire comme intermdiaire} Begin If N > 0 then Begin {Dplacer N - 1 disques de tour_origine sur tour_intermediaire en utilisant tour_destination comme intermdiaire} deplacer(N 1, tour_origine,tour_intermediaire,tour_destination); {Dplacer le disque restant de tour_origine sur tour_destination} {On reprsente cela par l'affichage d'un message l'cran} Write('Deplacer le disque restant de la tour',tour_origine:2); Writeln(' sur la tour',tour_destination:2); {Dplacer N - 1 disques de tour_intermdiaire sur tour_destination en utilisant tour_origine comme intermdiaire} deplacer(N 1,tour_intermediaire,tour_destination,tour_origine); End; End;
Exercice 76 Les tours de Hano Inclure la procdure de l'exemple ci-dessus dans un programme et en vrifier le fonctionnement. Complter le programme pour afficher le nombre de dplacements.
10 -26 Rv. 443
D.VIESLET
10.7 Les effets de bord

On dsigne ainsi des effets annexes, gnralement indsirables, qui apparaissent dans certains cas, la suite d'une utilisation abusive d'une variable globale ou d'un passage d'arguments par variable. Exemple 1: si une variable globale est modifie l'intrieur d'une procdure.
Program BORD1; Var A, B: Integer; Procedure P1(X, Y: Integer); Begin Y := X*Y; A := Y+5; End; Begin A := 2; B := 3; P1(A,B); Writeln(' Aprs le premier passage dans P1 A vaut: ',A); P1(A,B); Writeln(' Aprs le second passage dans P1 A vaut: ',A); End.
Instructions A :=2 B :=3 1er appel de P1(A,B) Y:=X*Y A := Y + 5 2me appel de P1(A,B) Y:=X*Y A := Y + 5
A 2 2 2 11 11 11 38
B 3 3 3 3 3 3 3
X -2 2 2 11 11 11
Y -3 6 6 3 33 33
Valeur affiche
A=11
A = 38
On pouvait s'attendre ce que les deux instructions Writeln donnent le mme rsultat puisque les paramtres effectifs des deux appels de la procdure sont apparemment les mmes; mais il n'en est rien. La cause est que la variable globale A est affecte par un traitement au sein de la procdure. Exemple 2: si un paramtre formel d'une fonction est dclar comme variable. Dans ce cas, ce paramtre risque d'tre modifi la sortie de la fonction. Une telle fonction est inhabituelle, dans la mesure o elle ne laisserait pas son argument inchang.
Program BORD2; Var A, B: Integer; Function F1(X: Integer; Var y: Integer): Integer; Begin
D.VIESLET
10 -27 Rv. 443
Y := X * Y; F1 := Y + 5; End; Begin A := 2; B := 3; Writeln(' Aprs le premier appel de la fonction F1 vaut ', F1(A,B)); Writeln(' Aprs le second appel de la fonction F1 vaut ', F1(A,B)); End.
Instructions A :=2 B :=3 1er appel de F1(A,B) Y := X * Y F1 :=Y+5 me 2 appel de F1(A,B) Y := X * Y F1:=Y + 5
A 2 2 2 2 2 2 2
B 3 3 6 6 6 12 12
X -2 2 2 2 2 2
Y -3 6 6 6 12 12
Valeur affiche
F1 = 11
F1 = 17
10.8 Synthse sur les procdures et fonctions

Une procdure est une suite d'instructions dcrivant une action simple ou compose laquelle on donne un nom. Une procdure sans paramtre n'change aucune donne, propre la procdure, avec le programme appelant. Dans le cas d'une procdure avec paramtres, len-tte de la dclaration contient la liste des paramtres formels, et l'appel de la procdure contient la liste des paramtres effectifs. Les deux listes doivent correspondre pour l'ordre, le nombre et le type des paramtres. Si une procdure doit fournir un rsultat au programme appelant, le paramtre formel correspondant doit tre prcd du mot VAR dans l'en-tte. Dans ce cas, le passage de paramtre se fait par variable et non par valeur. Un procdure de niveau I peut appeler une procdure de niveau I + 1, si elle la contient. Une procdure peut s'appeler elle-mme, on parle alors de rcursivit. Toute variable locale la premire est globale pour la seconde. Toute variable locale la seconde est inaccessible la premire. Une fonction est une procdure particulire qui ne transmet qu'une seule valeur au programma appelant. Le type de la variable associe au nom de la fonction doit tre prcis dans l'en-tte de sa dclaration. L'utilisation de procdures et de fonctions entrane parfois des effets de bords indsirables qu'il convient d'viter. On peut se demander s'il existe des rgles systmatiques pour savoir quand on doit utiliser une fonction et quand on doit utiliser une procdure. La rponse est ngative. On peut toutefois dgager les lignes de conduite suivantes: 10 -28 Rv. 443 Principes et mthodes de programmation Les procdures et fonctions dfinies D.VIESLET
- Si le rsultat attendu est unique et de type simple, il est possible d'utiliser une fonction; dans le cas contraire, il faut utiliser une procdure; - Dans le doute, on peut utiliser une procdure. En effet, toute fonction peut tre transforme en procdure.
D.VIESLET
10 -29 Rv. 443

Principes Et Méthodes de Programmation2 PDF

Transféré par

Informations du document

Titre original

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

Principes Et Méthodes de Programmation2 PDF

Transféré par

Droits d'auteur :

Formats disponibles

PASCAL

Principes et mthodes de programmation

Principes et mthodes de programmation

Principes et mthodes de programmation

Principes et mthodes de programmation

Principes et mthodes de programmation

1.2 Un peu d'histoire

Principes et mthodes de programmation Introduction

1.4 Le Pascal en micro-informatique

1.5 C'est en programmant que l'on devient programmeur

Dev-Pascal de BloodShed Software FreePascal

Principes et mthodes de programmation Introduction

Principes et mthodes de programmation Introduction

Principes et mthodes de programmation Gnralits

2.2 La programmation structure

Principes et mthodes de programmation Gnralits

2.3 Structure d'un programme Pascal

2.3.2 Les dclarations

Elle se divise en plusieurs sections diffrentes. Dclaration des:

Librairies Constantes Types Variables Procdures Fonctions tiquettes

2.3.3 Le corps du programme

2.4 Les units lexicales d'un programme Pascal

2.4.2 Le jeu de caractres Pascal

( ) [ ] { } + * / < = > : ; . , ' ^ $ #

2.4.3 Les identificateurs

Adoptez un significatif de ce que l'identificateur reprsente: vitez

Principes et mthodes de programmation Gnralits

2.4.4 Les identificateurs prdfinis

En voici une liste alphabtique

BOOLEAN CHAR CHR COS DISPOSE EOF

Remarque: chaque version de Pascal possde des identificateurs prdfinis supplmentaires!

Principes et mthodes de programmation Gnralits

2.4.5 Les mots-cl

2.4.6 Les symboles

Principes et mthodes de programmation Gnralits

2.4.7 Les constantes

Les constantes numriques (entires ou relles). Exemples:

1 +123 -36 12.3 -25.4 124e3

Les constantes caractres, c'est--dire un caractre entre apostrophes. Exemples:

'a' '?' 'X'

'Bonjour tout le monde' 'CARRE' 'Jules Dupont' '###.##' 'Espce de @$&'

Principes et mthodes de programmation Gnralits

2.4.8 Les commentaires

Cela vite de devoir appeler le programme

2 -10 Rv. 443

Principes et mthodes de programmation Gnralits

2.4.9 Rgles gnrales du langage Pascal

Principes et mthodes de programmation Gnralits

2 -11 Rv. 443

3 Les variables: premire partie

Au tout dbut du programme dans la section VAR avec la syntaxe

3.3 Les types de variables

On peut schmatiser cette classification comme suit:

Types scalaires Entier Enumr Caractre Intervalle Boolen

Types structurs Tableau Chane Ensemble

Principes et mthodes de programmation Les variables: premire partie

3.4 Prise de valeurs ou affectation

3.5 Les types simples

4 (*) [ -2147483648 .. +2147483647]

Principes et mthodes de programmation Les variables: premire partie

3.5.2 Le type boolen

3.5.3 Le type caractre

Principes et mthodes de programmation Les variables: premire partie