pascal
On utilisera bien évidement une fonction récursive, et l'on séparera le calcul de
...... J'enseigne principalement l'informatique (C, PROLOG, Algorithmique) et ...
part of the document
ste bien meilleur pour le débutant et le programmeur moyen : parfaitement structuré et clair, il conduit rapidement à un programme de bonne qualité et assez facilement maintenable (ce qui l'est moins en C, qui possède trop souvent trop de possibilités pour résoudre le même problème).
De plus, on trouve des compilateurs Pascal très conviviaux (Turbo Pascal sur PC, avec aide en ligne, déboguage,...).
Ce document reste donc d'actualité : le Pascal est d'après moi une très bonne manière d'aborder la programmation. C'est pourquoi j'ai choisi de mettre à disposition ce document sur Internet, qu'il serve à qui en a besoin ! Néanmoins, je n'ai pas passé trop de temps à sa mise en page, les graphiques restent en mode caractère, il n'y a pas de lien direct entre les sujets d'exercices et leur correction (que l'on trouvera en fin du document).
Voici quelques adresses intéressantes :
LIENHYPERTEXTE "http://www.mygale.org/~jmy51"Pascalissime (http://www.mygale.org/~jmy51)
LIENHYPERTEXTE "http://members.aol.com/cbaussaron/bcpasc.htm"Point de rencontre des utilisateurs de Borland Pascal (http://members.aol.com/chaussaron/bcpasc.htm)
LIENHYPERTEXTE "http://www.borland.fr"Site officiel de Borland France (http://www.borland.fr)
Copyright : utilisation de ce document libre pour tout usage personnel. Utilisation autorisée pour tout usage public non commercial, à condition de citer son auteur (LIENHYPERTEXTE "http://www-ipst.u-strasbg.fr/pat"Patrick TRAU, LIENHYPERTEXTE "http://www-ipst.u-strasbg.fr/ipst"IPST, LIENHYPERTEXTE "http://www-ulp.u-strasbg.fr"Université Louis Pasteur Strasbourg) et de me signaler tout usage intensif. Utilisation commerciale interdite sans accord écrit de ma part.
Table des Matières
TM \o "1-3" PASCAL RENVOIPAGE _Toc435007139 \h 1
Langage PASCAL RENVOIPAGE _Toc435007140 \h 2
Table des Matières RENVOIPAGE _Toc435007141 \h 3
INTRODUCTION RENVOIPAGE _Toc435007142 \h 4
LES LOGICIELS RENVOIPAGE _Toc435007143 \h 4
ORGANISATION DE L'ORDINATEUR RENVOIPAGE _Toc435007144 \h 4
LANGAGES DE PROGRAMMATION RENVOIPAGE _Toc435007145 \h 4
UN PREMIER PETIT PROGRAMME RENVOIPAGE _Toc435007146 \h 6
CONSTANTES RENVOIPAGE _Toc435007147 \h 8
INSTRUCTION D'AFFECTATION RENVOIPAGE _Toc435007148 \h 9
LES TYPES DE VARIABLES STANDARD SIMPLES ET OPERATEURS ASSOCIES RENVOIPAGE _Toc435007149 \h 10
ENTIERS RENVOIPAGE _Toc435007150 \h 10
REELS RENVOIPAGE _Toc435007151 \h 10
BOOLEENS RENVOIPAGE _Toc435007152 \h 10
CARACTERES RENVOIPAGE _Toc435007153 \h 11
LES FONCTIONS STANDARD RENVOIPAGE _Toc435007154 \h 12
INSTRUCTION RENVOIPAGE _Toc435007155 \h 13
STRUCTURES DE CONTROLE RENVOIPAGE _Toc435007156 \h 14
BOUCLE WHILE - DO (tant que - faire) RENVOIPAGE _Toc435007157 \h 14
BOUCLE REPEAT - UNTIL (répéter - jusqu'à ce que) RENVOIPAGE _Toc435007158 \h 14
BOUCLE FOR - DO (pour - faire) RENVOIPAGE _Toc435007159 \h 15
INSTRUCTION IF - THEN - ELSE (si - alors - sinon) RENVOIPAGE _Toc435007160 \h 15
LA STRUCTURE CASE - OF (cas - parmi) RENVOIPAGE _Toc435007161 \h 16
TYPES ENUMERES NON STANDARDS RENVOIPAGE _Toc435007162 \h 17
LES TYPES INTERVALLES RENVOIPAGE _Toc435007163 \h 18
TABLEAUX RENVOIPAGE _Toc435007164 \h 19
TABLEAUX UNIDIMENSIONNELS RENVOIPAGE _Toc435007165 \h 19
LES CHAINES DE CARACTERES RENVOIPAGE _Toc435007166 \h 19
TABLEAUX DE TABLEAUX RENVOIPAGE _Toc435007167 \h 20
TABLEAUX COMPACTES RENVOIPAGE _Toc435007168 \h 20
ENREGISTREMENTS RENVOIPAGE _Toc435007169 \h 21
DECLARATION RENVOIPAGE _Toc435007170 \h 21
UTILISATION DES ENREGISTREMENTS RENVOIPAGE _Toc435007171 \h 21
LA STRUCTURE WITH - DO (avec - faire) RENVOIPAGE _Toc435007172 \h 22
ENREGISTREMENTS AVEC VARIANTES RENVOIPAGE _Toc435007173 \h 22
PROCEDURES ET FONCTIONS RENVOIPAGE _Toc435007174 \h 24
GENERALITES RENVOIPAGE _Toc435007175 \h 24
PORTEE DES DECLARATIONS RENVOIPAGE _Toc435007176 \h 25
ARGUMENTS (OU PARAMETRES) RENVOIPAGE _Toc435007177 \h 26
LES FONCTIONS RENVOIPAGE _Toc435007178 \h 26
RECURSIVITE RENVOIPAGE _Toc435007179 \h 27
LES ENTREES / SORTIES RENVOIPAGE _Toc435007180 \h 29
SUR LA CONSOLE RENVOIPAGE _Toc435007181 \h 29
LES FICHIERS DE TEXTE RENVOIPAGE _Toc435007182 \h 30
EXTENSIONS NON STANDARD RENVOIPAGE _Toc435007183 \h 31
ENSEMBLES RENVOIPAGE _Toc435007184 \h 32
POINTEURS RENVOIPAGE _Toc435007185 \h 33
LES LISTES CHAINEES ET ARBRES RENVOIPAGE _Toc435007186 \h 33
LES POINTEURS EN PASCAL RENVOIPAGE _Toc435007187 \h 34
CORRECTION DES EXERCICES RENVOIPAGE _Toc435007188 \h 36
Qui suis-je ? RENVOIPAGE _Toc435007204 \h 48
INTRODUCTION
LIENHYPERTEXTE \l "Heading2"LES LOGICIELS
LIENHYPERTEXTE \l "Heading3"ORGANISATION DE L'ORDINATEUR
LIENHYPERTEXTE \l "Heading4"LANGAGES DE PROGRAMMATION
LES LOGICIELS
Dans la majorité des cas, on achète des programmes (logiciels) tout faits qui correspondent plus ou moins au besoin :
* Traitement de texte - P.A.O :avec mise en page, justification, numérotation chapitres - pages, table des matières, dictionnaire...
* Tableur : tableau de nombres à 2 dimensions et calculs
* Base de données : ensemble de fiches (nom, adresse...) et recherche par rubrique, publipostage...
* C.A.O, Dessin par ordinateur : propre, modification aisée, archivage...
* Gestion : paye, facturation, stock...
* Communication : transfert de programmes par modem et ligne téléphonique, serveur minitel...
Un Intégré regroupe plusieurs de ces possibilités.
Soit on achète un logiciel général : très bon niveau, parfaitement testé, documentation, formation... mais trop général (fonctions inutiles, fonctions utiles avec trop de paramètres ou difficilement accessibles). Soit on fait (ou fait faire) un logiciel particulier : plus pratique, mais plus hasardeux (erreurs, SAV, doc...). Le cahier des charges doit être très précis.
ORGANISATION DE L'ORDINATEUR
* Multiposte : plusieurs consoles sur un même ordinateur (CPU puissant, tout est partageable)
* Réseau : plusieurs CPU et MC non partageable (sauf réseau de multipostes), MdM et périphériques partageables ou locaux.
LANGAGES DE PROGRAMMATION
Un ordinateur est une machine bête, ne sachant qu'obéir, et à très peu de choses :
* addition, soustraction, multiplication en binaire, uniquement sur des entiers,
* sortir un résultat ou lire une valeur binaire (dans une mémoire par exemple),
* comparer des nombres.
Sa puissance vient du fait qu'il peut être PROGRAMME, c'est à dire que l'on peut lui donner, à l'avance, la séquence (la suite ordonnée) des ordres à effectuer l'un après l'autre. Le grand avantage de l'ordinateur est sa rapidité. Par contre, c'est le programmeur qui doit TOUT faire. L'ordinateur ne comprennant que des ordres codés en binaire (le langage machine), des langages dits "évolués" ont été mis au point pour faciliter la programmation.
Le PASCAL, créé par WIRTH au début des années 70, possède des instructions assez claires (si vous comprenez l'anglais), et favorise une approche méthodique et disciplinée (on dit "structurée").
Le PASCAL est un langage compilé, c'est à dire qu'il faut :
* entrer un texte dans l'ordinateur (à l'aide d'un programme appelé EDITEUR),
* le traduire en langage machine (c'est à dire en codes binaires compréhensibles par l'ordinateur) : c'est la compilation et éventuellement l'édition de liens (LINK),
* l'exécuter.
Contrairement à un basic interprété, l'exécution sera beaucoup plus rapide puisqu'il n'y a plus de traduction à effectuer.
Bien que le langage soit normalisé, un certain nombre de points dépendent de la machine et du compilateur utilisé (par exemple comment appeler le compilateur). Ces indications ne seront pas données ici. Si vous avez le choix, je vous conseille TURBO PASCAL, le plus pratique d'emploi (en particulier parce qu'il possède son propre éditeur de texte).
UN PREMIER PETIT PROGRAMME
Un programme PASCAL est composé d'une entête, des déclarations et des instructions (délimitées par BEGIN et END. ).
ex : PROGRAM cercle (input,output); (* entête *)
VAR perimetre,diametre : REAL; (* déclarations *)
BEGIN
readln(diametre); (* instruction *)
perimetre := 3.141592 * diametre; (* instruction *)
writeln(diametre,perimetre) (* instruction *)
END.
L'entête est composée du mot PROGRAM, suivi du nom du programme (cercle), et d'indications sur les Entrées/Sorties (ici le clavier et l'écran).
La partie déclarative de notre programme est limitée à la déclaration de deux variables (mot clef VAR). Une variable est une "case" mémoire de l'ordinateur, à laquelle on donne ici un nom. Chaque case peut contenir une valeur. On a précisé ici que nos deux variables PERIMETRE et DIAMETRE contiendraient des réels. Les types simples connus en PASCAL sont : REAL, INTEGER (entier naturel), CHAR (contient UN est un seul caractère), et BOOLEAN (booléen, c.a.d qui peut valoir soit TRUE (vrai) soit FALSE (faux). En TURBO PASCAL, les entiers admissibles sont compris entre -32768 et +32767. Dans tous les PASCALs on possède la variable prédéclarée MAXINT qui donne le plus grand entier admissible. Les réels doivent être compris en TURBO entre + et -1.7E37 (c.a.d 1,7 fois 10 puissance 37), avec 11 chiffres significatifs. La virgule décimale est toujours représentée par un point en informatique.
Un identificateur (tout nom que vous choisissez : variable, programme...) peut être formé de lettres (A à Z), de chiffres et (pas sur toutes les versions de PASCAL) du signe _ (souligné). TURBO PASCAL accepte des noms de 127 caractères maximum, certains PASCAL sont plus limités (31 caractères par ex). Le premier caractère doit être une lettre. Par exemple, VALEUR1 ou PREM_VALEUR sont possibles mais pas 1ERE_VALEUR. En PASCAL les minuscules sont traitées comme des majuscules (SURface et surFACE désignent la même case mémoire). Je n'utilise les majuscules que pour faire ressortir les mots importants. Les accents et autres ç ne sont pas autorisés (var diamètre:real est interdit à cause de l'accent). Un blanc dans un identificateur est également interdit (utilisez _ pour séparer des mots dans un même identificateur).
Toute variable utilisée dans un programme doit être déclarée. Ceci évite la plupart des erreurs de frappe, et rend le programme plus compréhensible.
Les instructions de notre programme sont :
* lecture sur le clavier :
le programme s'arrête, attend que l'on donne une valeur à l'aide du clavier, met cette valeur dans la case DIAMETRE et continue le programme lorsque l'on appuie sur la touche "ENTREE" ou "RETURN".
* calcul et affectation :
on multiplie le contenu de la case DIAMETRE par PI, et on met le résultat dans la case PERIMETRE.
Le := symbolise une flèche à gauche. Ce n'est PAS une égalité au sens mathématique, mais la copie d'une valeur dans une mémoire.
* écriture sur l'écran :
on affiche sur l'écran le contenu des case DIAMETRE (que l'on connaissait puisque nous l'avions donné) et PERIMETRE (qui nous intéresse un peu plus). Ce programme affiche donc deux chiffres. Il serait plus parlant d'afficher également des commentaires par l'instruction :
writeln('Diamètre : ',diametre,', Périmètre : ',perimetre)
Les textes doivent être entourés de cotes ('). Les majuscules/minuscules sont significatives. Pour afficher une apostrophe utiliser deux cotes ('l''exemple'). Pour sauter une ligne utiliser WRITELN seul.
Les instructions doivent toujours être séparées par des ";" (j'ai dit "séparées", pas "terminées"). Le fait de passer à la ligne n'est interprété par l'ordinateur que comme un blanc. On aurait donc pu écrire notre programme sur une seule ligne (peut-être un peu longue pour l'éditeur). Le programme doit toujours se terminer par un point.
On peut insérer des remarques dans le programme (qui ne seront pas lues par le compilateur) en les entourant par (* et *) ou { et }. On ne peut en standard pas imbriquer des commentaires. Les commentaires peuvent faire plus d'une ligne, ceci permet de supprimer momentanément une partie d'un programme.
Chaque identificateur est séparé du suivant par un blanc. On considère comme un blanc : plusieurs blanc, un retour à la ligne, un commentaire.
EXERCICE (ex_tva) Faire un programme demandant le prix unitaire HT d'un article et sa quantité, puis qui affiche : le total Hors Taxes, le montant de la TVA (pour un taux de 18,6 %) et le total TTC.
CONSTANTES
Nous avons déjà utilisé des VARIABLES (on donne un nom à une mémoire). Mais on peut également utiliser des CONSTANTES, qui sont des valeurs qui restent fixes tout au long du programme et pour chaque exécution. On déclare les constantes avant de déclarer les variables, par : CONST nom=valeur
ex : CONST taux_tva=18.6
MAXINT (plus grand entier possible) est une constante prédéfinie.
On peut également avoir des constantes de type "chaîne de caractères" :
PROGRAM bonjour(output); { on n'a pas besoin ici du clavier }
CONST message1='salut, ça va ?';
message2='moi ça baigne';
BEGIN
writeln(message1);
writeln(message2) (* notez l'absence de ; devant le END *)
END.
Le type de la constante est déterminé automatiquement par le compilateur (entier si nombre sans point, réel si nombre avec point, caractères si entre cotes).
Rq1: on peut toujours utiliser un entier à la place d'un réel mais pas l'inverse.
Rq2: si on utilise un point décimal, il FAUT l'encadrer de chiffres (0.3 et non .3 , 10 ou 10.0 et non 10.)
INSTRUCTION D'AFFECTATION
On appelle AFFECTATION la mise d'une valeur dans une variable. Celle-ci peut être sous forme directe (A:=B) ou sous forme d'un calcul (A:=B*C). Le signe := représente une flèche à gauche, et signifie "mettre la VALEUR à droite du := dans la mémoire désignée à gauche" (mettre le contenu de B dans A ou mettre le résultat du calcul (contenu de B) fois (contenu de C) dans A). Une affectation du type B*C:=A est donc IMPOSSIBLE.
Une affectation ne peut se faire qu'entre une variable et une expression de même type (si A est réel, impossible de faire A:='xyz'). La seule exception est de mettre un entier dans un réel (le .0 est rajouté automatiquement), mais l'inverse est impossible directement. Soient I entier et X réel, pour mettre X dans I il faut utiliser I:=ROUND(X) (arrondi) ou I:=TRUNC(X) (partie entière).
On peut également utiliser des affectations et expressions booléennes. Par exemple, en ayant déclaré :
VAR test:boolean;
a,b:real;
on peut écrire : TEST:=(A0)
LES TYPES DE VARIABLES STANDARD SIMPLES ET OPERATEURS ASSOCIES
LIENHYPERTEXTE \l "Heading9"ENTIERS
LIENHYPERTEXTE \l "Heading10"REELS
LIENHYPERTEXTE \l "Heading11"BOOLEENS
LIENHYPERTEXTE \l "Heading12"CARACTERES
Tous ces types, excepté les réels, sont dits "énumérés".
ENTIERS
déclaration : VAR variable1,variable2,...,variableN : INTEGER;
opérations sur entiers : + - * div (division) mod (reste de la division). Elles sont toutes à résultat entier, et nécessitent deux arguments entiers.
Les entiers sont compris entre -MAXINT et +MAXINT qui est une constante standard prédéfinie (sa valeur dépend par contre du compilateur, 32767 en TURBO).
REELS
déclaration : VAR liste de variables : REAL;
opérations : + - * /
Quand une opération comprend un argument réel et un entier, le résultat est réel. / donne toujours un résultat réel, même si les deux arguments sont entiers.
* et / sont de priorité supérieure à + et -, mais entre * et / tout dépend du compilateur (en général de gauche à droite). En cas d'ambiguïté, utilisez des parenthèses (il n'y a aucun inconvénient à mettre plus de parenthèses que nécessaire).
Exemples d'expressions numériques (soit A=3, B=4, C=2):
A+B/C = A+(B/C) = 5
(A+B)/C = 3.5
A/B*C = (A/B)*C (1.5) dans certains cas, A/(B*C) (0.375) dans d'autres
A/BC = valeur de A sur valeur de la variable de nom BC et non A sur B*C
B*A-5*C = (B*A)-(5*C) = 2
BOOLEENS
déclaration : VAR liste de variables : BOOLEAN;
Ces variables peuvent prendre soit la valeur TRUE (vrai), soit la valeur FALSE (faux).
opérations booléennes : AND, OR, NOT, et (non standard) XOR (ou exclusif). Ces opérations nécessitent des arguments booléens.
opérations à valeur booléenne : > (supérieur), < (inf), >= (sup ou égal), 0) and (n0) and (n0) and (n
