Formation sur les types du langage Pascal pdf


Télécharger Formation sur les types du langage Pascal pdf

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Formation sur les types du langage Pascal

...

Les spécificités de Turbo Pascal 3.0

L’édition, la compilation

Turbo Pascal fournit un petit éditeur de texte. Pour y accéder, il suffit de presser E lorsque vous êtes au menu. Pour compiler un programme source, pressez C. Il sera compilé en mémoire. Si vous voulez le compiler en créant un fichier COM, pressez O (Options), puis C (Com-File), Q (Quitter le menu des options) et enfin C (Compile). Pour l'exécuter il ne vous restera plus qu'à quitter Turbo Pascal et à lancer le fichier COM.

Les touches de fonction F7, F8

Les touches du bloc curseur remplissent les fonctions usuelles d'édition. Les touches de fonction F7 et F8 délimitent respectivement le début et la fin d'un bloc.

La séquence ce touches Ctrl-K, C

Les touches Ctrl-K puis C recopie le bloc sélectionné par F7 et F8 à l'endroit positionné par le curseur. Les touches Ctrl-K puis Y effacent le contenu de ce bloc.

La séquence de touches Ctrl-K, W, Ctrl-K, R

Les touches Ctrl-K puis W permettent d'enregistrer sur disque le bloc sélectionné, tandis que Ctrl-K puis R effectue le contraire : la lecture du bloc.

Les directives

Vous pouvez fournir une directive de compilation à Turbo Pascal :

"{$lettre}", lettre désignant une lettre ou un groupe de lettres d'une ou de directives de compilation.

Voici une liste de directives de Turbo Pascal :

Directive             Description

{$I+}      Contrôle des Entrées - Sorties autorisé (par défaut)

{$I-}       Contrôle des Entrées - Sorties interdit

{$V+}    Test de la longueur d'une chaîne autorisé (par défaut)

{$V-}     Test de la longueur d’une chaîne interdit

{$R+}     Contrôle de l'index de champ autorisé

{$R-}      Contrôle de l’index de champ interdit (par défaut)

Les étiquettes et le branchement direct [LABEL, GOTO]

L’utilisation de Label et de Goto est une mauvaises habitudes.

Turbo Pascal admet les instructions :

Label NOM

...   ...

Goto NOM

L'intérêt d'une telle instruction est visible par exemple dans le cas suivant :

Si erreur Alors

Faire

   Message d'erreur

   Aller à la fin du programme

FinFaire

Corps du programme

La sortie [EXIT, HALT]

Deux autres instructions sont aussi utilisées :

Exit quitte le bloc programme courant

Halt quitte le programme

 Historique

La naissance de Pascal

Pascal est un langage de programmation créé en 1963 par le Professeur Niklaus Wirth de l'Eidgenossisch Technische Hochshcule de Zurich. Il a pris naissance après constatation de Dahl et de Dijkstra que 50 % du coût de l'élaboration d'un logiciel incombait à la maintenance, contre 10 % seulement pour la première écriture du programme. Ceci explique la naissance d'un langage de science exacte, et non pas artistique.

Wirth s'est inspiré de l'Algol, et a doté Pascal d'une certaine cohérence (il en est le seul auteur, au contraire de Ada), d'une simplicité, et d'une efficacité.

L’évolution de Pascal

Plusieurs versions ont été dès lors créées :

  • première version à Zurich sur un CDC 6000
  • implantation sur micro-ordinateurs effectuée par Kenneth   BOWLES de l'Université of California at San Diego (UCSD) : version optimisée (overlays, librairies, utilisation statistiques pour la fréquence des instructions, ...),
  • beaucoup d'autres : TINY PASCAL, PASCAL MT+, PASCAL JRT, ...
  • et maintenant le phénomène TURBO PASCAL.

Le P Code

Dès l'origine apparut l'idée suivante =

  • le programme source est transformé en P Code, véritable langage indépendant de la machine (90 % du travail total à fournir).
  • le P Code, comprit par une machine virtuelle (P Machine) est alors transformé en langage machine sur la machine spécifique (10 % du travail total à fournir).

Les bases

Introduction

La syntaxe est un ensemble de règles d'utilisation des mots, nombres et ponctuation.

Les identificateurs

Les noms, ou identificateurs, sont fournis dans les procédures, fonctions et variables. Un identificateur reconnait au maximum huit caractères. Toutefois, vous pouvez en utiliser plus, à condition cependant de ne pas oublier que seuls les huit premiers seront reconnus par le langage.

Les règles

Il y a trois règles pour les identificateurs :

  • ils doivent tous commencer par une lettre
  • les caractères suivant le premier doivent être soit une lettre soit un chiffre, et rien d'autre
  • les mots réservés ne peuvent être utilisés comme noms d'identificateurs.

La structure du programme

Indiquer le nom du programme [Program]

Un programme doit commencer par le mot réservé PROGRAM suivi du caractère ; (point virgule).

Définir un bloc [Begin, End]

Puis il faut fournir le jeu d'instruction dans le « Block Statement », qui comprend à la fois BEGIN et END. A l'unique exception « END. », tous les ordres du programme doit finir par un point-virgule.

Enfin, tous les ordres du programme principal sont décalés de trois espaces par rapport à BEGIN.

Insérer un commentaire [(* *) { }]

Des commentaires peuvent être ajoutés n'importe où dans un programme. Ils sont introduits par (* et terminés par *). Ils seront ignorés aussi bien lors de l'exécution du programme que lors de la compilation du source.

Le contrôle de l’écran

Afficher un texte [Write, WriteLn]

Les ordres WRITE et WRITELN affichent des messages à l'écran. WRITE permet d'afficher plusieurs mots, tandis qu'à chaque exécution de WRITELN, un saut de ligne et un retour chariot sont opérés.

Positionner le curseur [GotoXY

On peut également déplacer le curseur sur l'écran par emploi de l'ordre GOTOXY. Le coin supérieur gauche correspond au point de coordonnées 0,0. Le point de coordonnées 1,1 correspond au point situé à l'intersection de la deuxième colonne et de la deuxième ligne.

Contrôler l’affichage [ClrScr, Delay, DelLine, InsLine, CtrEol]

De plus, Pascal met à votre disposition un certain nombre d'instructions très utiles :

Instruction         Description

ClrScr    Efface l'écran et place le curseur en haut à gauche de l'écran

Delay    Attend Temps millisecondes

DelLine Efface la ligne contenant le curseur

InsLine Insère la ligne contenant le curseur

CtrEol    Efface de la position du curseur jusqu'à la fin de la ligne

La présentation

Le débordement de ligne

Dans l'éventualité où la liste des paramètres ne tienne pas sur une ligne, arrangez-vous, si possible, de faire aligner les suivants avec les précédents.

Les deux ordres WRITELN (liste de données); et WRITE (liste de données); WRITELN; sont équivalents.

Lorsqu'une assignation d'une expression à une variable est faite et qu'elle ne tient pas sur une ligne, la suite est inscrite juste sous la partie précédente de l'expression. Pour READ et READLN, c'est la même chose que pour WRITE et WRITELN.

Les conseils

Les abréviations

Premier conseil : dans la limite du possible, évitez de dépasser huit caractères de longueur pour les noms d'identificateurs, afin d'éviter le conflit de nomrs dû à d'éventuelles duplication. Essayez donc d'utiliser des abréviations standards, comme lorsque vous prenez des notes lors d'une conférence.

Dans le même ordre d'idées, évitez de trop abréger les noms d'identificateurs puisqu'il y a alors risque de créer des noms qui se ressemblent, source d'erreur.

Les commentaires

Deuxième conseil : afin de faciliter la compréhension du programme, placez des commentaires entre les BEGIN...END.

Un commentaire placé au début renseigne sur l'auteur, la date d'écriture, le numéro de la version, ...

Les paramètres

Troisième conseil : les paramètres (ce qui est situé entre parenthèses), devraient être séparés par une virgule (,), suivi d'un espace ( ), le tout pour faciliter la relecture du programme. De même, il serait judicieux de placer un espace juste aprsès la parenthèse d'ouverture.

La déclaration, l’assignation

Les variables

Les variables sont des emplacements dans la mémoire de l'ordinateur. Elles portent chacunes un nom. Vous devez déclarer lesquelles seront utilisées, ainsi que les genres de valeurs qu'elles prendront.

Nommer une variable

Chaque nom de variable est décalé de trois espaces de VAR. A sa droite, doit figurer un commentaire explicitant son utilisation. Chaque type de variable est décalé de trois espaces, suivant la syntaxe « : type; ». Pour ce qui est des attributs de longueur (entre accolades), le même traitement est fait que pour les parenthèses.

Evaluer une variable

Le résultat d'une opération arithmétique sera réel si l'un au moins des facteurs est réel.

Déclarer une variable [Var]

VAR est le mot réservé qui indique à l'ordinateur que vous allez utiliser des variables. Leur nom et leur champ de valeur sera indiqué juste après VAR.

La déclaration VAR doit être décalée de trois espaces, et une ligne doit être sautée à la fois avant l'ordre VAR et après la dernière variable déclarée.

L'ordre VAR reconnait les types suivants.

Type      Description



Integer Nombre entier compris entre 32767 et - 32768

Byte      Sous ensemble de INTEGER, compris entre 0 et 255

String    Chaîne de caractères d'au plus 80 caractères s'il figure [nombre] juste après STRING, alors la chaîne est limitée au nombre indiqué entre parenthèse (limite supérieure fixée à 256)

Char      Un seul caractère

Boolean               Contient la valeur TRUE (vrai) ou FALSE (faux)

Real       Nombre réel (souvent exprimé en notation scientifique)

Affecter une valeur à une variable

Affecter une expression à une variable [:=]

« Assignation directe » range une valeur directement dans une variable. Le symbole « := » est alors placé entre le nom de la variable (à gauche) et la valeur (à droite).

Le schéma d'une affectation directe est le suivant :

Variable_Réceptrice := Expression_Source;

Une expression étant une suite hiérarchisée d'opérations élémentaires. Notez que le résultat d'une opération arithmétique est réel si l'un au moins des facteurs est réel.

Affecter une valeur lue au clavier à une variable [Read]

L'ordre READ permet à l'ordinateur de capter une donnée en cours d'exécution du programme. Utilisez READ si un « enter » (ou return) n'est pas obligatoire à la fin de la saisie. Sinon, employée READLN.

Les variables BOOLEAN ne peuvent recevoir de valeur qu'en assignation directe. Avec les variables CHAR, READ est utilisé, mais la plupart du temps, ce sera READLN, puis qu'un return est le plus souvent demandé.

Les opérateurs

Introduction

Les opérateurs arithmétiques sont des symboles qiu indiquent à l'ordinateur d'effectuer certaines opérations mathématiques. On peut citer l'addition, la division, ... Ils sont utilisés avec des variables de type entier (INTEGER ou LONG INTEGER) ou réel (REAL).

Les opérateurs arithmétiques et de comparaison sont précédés et suivis d'un espace.

De plus, les expressions logiques (utilisant la logique booléenne) contenant plusieurs opérateurs doivent utiliser des parenthèses.

Les opérateurs arithmétiques [*, /, Div, Mod, +, -]

Ces opérateurs standards sont :

Opérateur          Description

*             Multiplication

/              Division

DIV        Division d'entiers

MOD     Module (le reste, nombre entier, de la division de X par Y)

+             Addition

-              Soustraction

Remarque : les résultats, sauf exception indiquée, sont des nombres réels.

Les opérateurs de comparaison [<, >, =, <>, <=, >=]

Voici maintenant une liste des opérateurs de comparaison :

Opérateur          Description

<             plus petit que

>             plus grand que

=             égal à (différent de :=)

<>          différent

>=          plus grand ou égal à (dans cet ordre !)

<=          plus petit ou égal à (dans cet ordre !)

Cas particulier : les chaînes de caractères.

Note : les comparaisons sont effectuées de la même manière pour les chaînes de caractères que pour les nombres. Un « A » est « plus petit » qu'un « B » ! (voir les codes ASCII pour plus de précisions).

Les fonctions arithmétiques [Abs, Cos, Exp, Frac, ...]

Voici d'autres fonctions arithmétiques disponibles :

Fonction              Description

Abs (Nombre)  Renvoit la partie absolue de nombre

ArcTan (Nombre)            Renvoit l'arc-tangente de nombre

Cos (Nombre)   Renvoit le cosinus de nombre

Exp (Nombre)   Renvoit l'exponentielle de nombre

Frac (Nombre)  Renvoit la partie décimale de nombre

Int (Nombre)    Renvoit la partie entière de nombre (en réel)

Ln (Nombre)     Renvoit le logarithme népérien de nombre

Pred (Nombre) Equivaut à Nombre := Nombre - 1

Sin (Nombre)    Renvoit le cosinus de nombre

Sqr (Nombre)   Renvoit le carré de nombre

Sqrt (Nombre)  Renvoit la racine carrée de nombre

Round (Nombre)            Renvoit l'arrondi à l'entier le plus proche de nombre (en entier)

Trunc (Nombre)              Renvoit la partie entière de nombre (en entier)

Random              Renvoit un nombre aléatoire compris entre 0 et 1

Random (Nombre)         Renvoit un nombre aléatoire compris entre 0 et nombre

Succ (Nombre) Equivaut à Nombre := Nombre + 1

Remarques

L’ordre des priorités

Après avoir tenu compte des priorités des opérateurs, l'ordinateur effectue les calculs de gauche à droite.

Voici l'ordre de priorité des opérateurs :

  • d'abord les multiplications et les divisions (*, /, DIV, MOD)
  • ensuite les additions et les soustractions (+, -)

Toutefois, vous pouvez indiquer à l'ordinateur d'effectuer un groupe d'opérations avant les autres (quelque soit leur degré de priorité). Ce groupe est délimité par des parenthèses, de la même manière qu'en mathématiques.

Note : pour effectuer les calculs, vous pouvez intégrer des opérateurs dans des expressions d'assignation de variables.

Les erreurs d'approximation

Attention, rappelez-vous que l'ensemble mathématiques de la machine n'est pas continu, à cause du manque de précision de l'ordinateur. Il peut donc arriver que certains résultats semblent présenter des erreurs.

Les répétitions

Introduction

Un des grands intérêts de l'ordinateur est la possibilité de répéter de nombreuses fois une même tâche. Les instructions de boucle ont donc été créés. Ils permettent donc de faire répéter une séquence d'instructions en un minimum d'instructions.

Voyons While et Repeat. Ils permettent la répétition d'une série d'ordres un certain nombre de fois. Ce nombre n'est pas pré-défini, puisque la boucle est effectuée tant que la condition indiquée est remplie.

La boucle While

La syntaxe de la boucle « while » est :

WHILE expression DO ordre;

Algorithme de While...Wend

J := a

Tant que <condition> et (J <= b) faire

Commencer

(ordres)

   J = J + pas         (équation de définition)

Fin

Fin de tant que

La condition d'arrêt est :

  • si p > 0 : (j > b) et (condition fausse)
  • si p < 0 : (j < b) et (condition fausse)

ou encore, cas particulier :

Tant que <condition> faire

Commencer

(ordres)

Fin

Si une seule instruction, on peut écrire Tant que "<condition> faire <ordre>"

La boucle Repeat

Et celle de la boucle « repeat » : "REPEAT ordre UNTIL expression;" où expression a un rôle de valeur booléenne.

L'algorithme de Repeat .. Until est le suivant :

Faire varier J de n à b par pas de p tant que <condition>

Pour chaque J

(ordres)

FinFaire

La boucle For

Voyons maintenant la boucle FOR. Sa syntaxe est "FOR variable:= expression1 TO expression2 DO ordre;" (parcours séquentiel en sens croissant) ou "FOR variable:= expression1 DOWNTO expression2 DO ordre;" (parcours séquentiel en sens décroissant).

Notez que la variable et les expressions doivent être du même type. De plus, le nombre de fois que la boucle est exécuté est égal à la différence entre les expressions plus un. La variable est utilisée comme compteur, ou variable de contrôle, et contient toutes les valeurs entières comprises entre expression1 et expression2.

Les paramètres To et DownTo

TO dit à l'ordinateur d'incrémenter le compteur. DOWNTO fait l'opposé : il y a décrémentation. Si avec TO, expression1 est inférieur à expression2, (ou le contraire avec DOWNTO), alors la boucle n'est pas du tout exécutée.

La fréquence de Begin .. End dans For

Les ordres entre BEGIN et END peuvent être aussi nombreux que vous le voulez. Toutefois, vous ne pourrez pas utiliser la variable de nom celui du compteur, sauf action précise sur le compteur recherchée. De plus, à la sortie de la boucle, la variable de contrôle doit être considérée comme ayant une valeur non définie. En ce sens, que sa valeur aura été altérée par la boucle.

Algorithme de For

Pour mieux comprendre les boucles de parcours conditionnelles, étudiez les deux algorithmes suivants :

Algorithme de FOR...NEXT :

(initialisation induites)



Faire varier J de a à b par pas de p tant que <condition>

Pour chaque J

(ordres)

FinFaire

(opérations finales)

Il y a deux critères d'arrêt, qui constituent ainsi une formulation d'une limite absolument nécessaire.

  • si p>0, ils sont J>b et condition fausse
  • si p<0, ils sont J<b et condition fausse

Naturellement, la condition d'arrêt doit être réalisable en un nombre fini d'itérations.

Remarques

La différence entre WHILE et REPEAT est que REPEAT vérifie l'expression à la fin de la boucle, alors que WHILE le fait, mais au début. Donc REPEAT est exécuté au moins une fois, alors que pour WHILE, ce n'est pas obligatoire.

REPEAT implique la présence de BEGIN...END. Et même, si vous l'ommettez, l'ordinateur en place une, mais « invisible ».

Mêmes conseils à appliquer que pour les autres chapitres : décaler de trois espaces les ordres situés dans les boucles fermées par FOR, WHILE ou REPEAT. Rappelez-vous cependant que la structure BEGIN..END n'est pas nécessaire dans une boucle REPEAT.

La boucle d'attente

En plaçant un point-virgule (;) juste après DO, vous générez une boucle d'attente, c'est-à-dire qu'un certain laps de temps s'écoule sans qu'aucune instruction ne soit exécutée.

 Utiliser For avec précaution

De plus, prenez garde à ceci. La structure :

FOR I := 1 TO 10 DO

   FOR J := 1 TO 10 DO

   BEGIN

   END;

BEGIN

END;

est valide. Mais la structure suivante est invalide :

FOR I := 1 TO 10 DO

BEGIN

   FOR J := 1 TO 10 DO

   END;

   BEGIN

   END;

Les conditions

Définition

Les ordres de condition constituent le coeur de tout programme effectuant une « décision ». Grâce à celles-ci, l'ordinateur devient très puissant.

Ces instructions sont :

IF expression THEN ordre;

ou

IF expression THEN ordre

   ELSE ordre;

où expression est de type booléen, et ordre est soit un ordre seul, ou alors une structure du type BEGIN..END.

Dans le premier cas, si (IF) l'expression est vraie, alors (THEN) exécute les ordre(s) suivants.

Dans le second cas, si (IF) l'expression est vraie, alors (THEN) exécute les ordre(s) suivants sinon (ELSE) exécute ces autres ordres.

IF..THEN..ELSE constitue un irdre en lui-même et doit donc satisfaire à la « règle du point-virgule ».

Le domaine de définition

Un algorithme est conçu pour un groupe de données (ou paramètres) dont le domaine de validité présente souvent des restrictions par rapport à leur ensemble de définition.

Tester une expression en fonction de plusieurs valeurs [Case]

Il existe un autre genre d'ordre conditionnel : CASE. La syntaxe est :

CASE expression OF

   constant: ordre;

   constant: ordre;

     ...      ...

   constant: ordre;

END;

L'instruction CASE permet de choisir un traitement, et un au plus, parmi plusieurs, en fonction d'un critère. Si aucune condition n'est remplie, il y a erreur. Si une condition est remplie, alors seul le traitement correspondant est exécuté, puis le programme reprend à la suite.

Remarques

L'expression et les constantes doivent évidement être du même type ! De plus, la constante ne peut être une variable.

Notez que là aussi, comme pour la boucle REPEAT, cette instruction a un BEGIN induit, mais pas un END cette fois. De plus, vous n'avez pas le droit de placer une BEGIN.

Combiner plusieurs constantes

Au cas où vous voulez combiner plusieurs constantes, en ce sens que si expression est égal à constante1 ou à constante2, ... vous devez placer les différentes constantes les unes après les autres, séparées chacunes d'une virgule. Nous vous conseillons toutefois de placer la première constante sur la première ligne, la seconde sur la seconde, ...

Les constantes sont décalées de deux ou trois espaces. Les commentaires seront plutôt placés à la fin des instructions CASE et IF.

Les conditions [If, Then, Else]

Toujours les conseils pour facilité la relecture et la compréhension du programme.

Tout d'abord, les ordres utilisés dans l'ordre IF doivent être décalés de 2 ou 3 espaces. Si vous utilisez un ELSE, il doit venir se placer sous le IF, et même chose pour ses ordres que pour IF.

Notez aussi que raccorder ELSE à l'ordre IF peut aider à identifier rapidement une instruction de branchement.

Le schéma d'un test est :

SI hypothèse satisfaite

ALORS (* donnée correcte *) lancer l'algorithme

SINON erreur de donnée

Ainsi, si la condition est remplie alors le premier traitement, et lui seul, est lancé (lancer l'algorithme). Si elle est fausse, alors seul le second traitement, et lui seul, est lancé (erreur de donnée).

Remarques

Une erreur classique

Attention l'erreur classique de placer un point-virgule (;) devant le ELSE ! Un IF est suivi d'un point-virgule si et seulement s'il précède une autre instruction dans le même groupe BEGIN.

Les tests en cascade

Remarquez l'intérêt des tests en cascade : il permettent d'améliorer les performances d'un programme, en y effectuant le minimum indispensable de tests.

Les procédures et les fonctions

Le bloc d'instructions

Chaque bloc en Pascal est identifié par un nom. Immédiatement après ce nom, se trouve le bloc lui-même, délimité par BEGIN..END.

La syntaxe est la suivante :

Nom (entrée : x, y, z; sortie : a, b);

a et b constituent les paramètres formels

x, y et z constituent les paramètres effectifs

Les types de variable

La variable globale

Une variable déclarée en début de programme est dite variable globale, puis qu'elle sera utilisée partout dans le programme.

La variable locale

Si une variable est déclarée à l'intérieur d'un bloc autre que le bloc principal, la variable est appelée variable locale. Celle-ci ne peut être accédée qu'à partir du bloc où elle a été déclarée.

La procédure [Procedure]

Elle est similaire au programme (PROGRAM). Toutefois, il existe deux différences :

  • le mot réservé PROCEDURE est utilisé à la place de PROGRAM
  • le END est suivi d'un point-virgule à la place d'un point.

L'objectif majeur d'une procédure est d'effectuer une tâche spécifique. Cette tâche, ou routine, est généralement exécutée plus d'une fois, et souvent appelée de divers endroits du programme.

Appeler une procédure à partir d'une autre procédure

Attention aussi à une chose : une procédure B peut appeler une procédure A à la seule condition que la définition de A figure avant celle de B. De plus, il doit alors y avoir correspondance absolue entre ces paramètres (même nombre, même type). De même, une constante, une variable, une procédure, ou une étiquette déclarée à l'intérieur d'une procédure n'est accessible qu'à partir de cette procédure.

Les méthodes d'appel d'une procédure

Il existe deux méthode pour appeler une procédure :

L’appel par valeur (paramètres récepteurs)

Une valeur est passée et utilisée localement dans la procédure.

Les variables encadrées de parenthèses sont locales à la procédure et nommées paramètres formels. La déclaration de ces paramètres formels se fait de façon similaire à celle faite avec VAR.

La liste de paramètres associée à l'ordre d'appelle d'une procédure constitue les paramètres actuels. Les paramètres formels et ceux actuels doivent se correspondre en type, en ordre, et en nombre.

L’appel par adresse (ou paramètres variables ou vrais)

Les paramètres variables permettent aux procédures d'utiliser et de retourner une valeur dans le paramètres actuel.

Différences entre les deux méthodes

Trois grandes différences marquent les deux méthodes :

  • les paramètres variables permettent le retour d'information d'une procédure par utilisation de la liste de paramètres, pas l'autre méthode.
  • un paramètre actuel DOIT être une variable lorsque vous utilisez des paramètres variable. Une valeur littéralle peut être passée à une valeur de paramètre de type STRING, mais pas à un paramètre variable.
  • vous définissez une paramètre variable dans une liste de paramètres en plaçant un préfixe VAR.



594