MEMENTO DE TURBO-PASCAL pour les prépas ECE

Sommaire

1 Qu'est-ce qu'un algorithme ?
2 Schéma général d'un programme en Pascal
3 Variables
   3.1 Syntaxe d'une déclaration de variable :
   3.2 Syntaxe d'une affectation de variable :
4 Types
   4.1 Syntaxe d'une déclaration de type:
5 Constantes
6 Entrée des données et sortie des résultats
   6.1 Entrées
   6.2 Sorties
7 Les instructions
   7.1 L'affectation
      7.1.1 Expressions, Opérateurs
   7.2 Appel de procédure
   7.3 Instruction composée
   7.4 Instruction conditionnelle
   7.5 Instruction répétitive:
      7.5.1 tant que... faire ...,
      7.5.2 répéter... jusqu'à ce que ... ,
      7.5.3 pour ... de ... à ... faire ... .
8 Les sous programmes
   8.1 Variables locales, variables globales.
   8.2 Les paramètres
   8.3 Action des sous programmes.
   8.4 Résultat d'une fonction
   8.5 Syntaxe de déclarations des sous programmes
9 Les fonctions usuelles pour le calcul scientifique.

1 Qu'est-ce qu'un algorithme ? 

Un algorithme est une suite d'instructions qui indique les opérations à effectuer dans l'ordre, pour parvenir aux résultats désirés.

Une fois l'algorithme établi, nous le traduirons en langage Turbo-Pascal. Tout algorithme (programme) écrit en Pascal doit impérativement commencer par l'identificateur PROGRAM suivi de son nom écrit de manière continue puis du séparateur ";".(pour des raisons de lisibilité, on peut séparer artificiellement le nom par des sous-traits"_"). Ensuite on déclare les constantes, les variables, les fonctions etc. Dans cette étape, il est interdit d'utiliser les mots réservés du langage.

Viennent enfin les instructions du corps du programme qui seront écrites entre BEGIN et END.

2 Schéma général d'un programme en Pascal 

PROGRAM Démonstration_du_Pascal; {C'est l'entête du programme}
USES ... ; {Déclarations début...........
TYPE montab =.....;
CONST a,b. =..;
VAR X,Y..: ;
FUNCTION (...) : ... ;
PROCEDURE(....);
............ Déclarations fin}
{début du corps du programme principal}
BEGIN
instruction 1;
instruction 2;
.....
END.

{fin du corps du programme principal}

Important

Pour expliquer une étape du programme, un symbole ou une formule, on met les explications ou commentaires correspondants entre { } ou (* *). Le compilateur du Turbo Pascal ne tient pas compte de ces dialogues !

3 Variables 

Qu'est-ce qu'une variable en Pascal ?

C'est par les variables que les données sont introduites, sont stockées pour être traitées et c'est encore grâce aux variables que les résultats finaux du calcul nous parviennent. Les variables faisant partie du programme doivent être déclarées au préalable.

Pour que la variable soit reconnue lors de la lecture ou de l'exécution du programme on lui attribue un nom ( identificateur de la variable). Ce nom (identificateur) doit être une chaîne de caractères alphabétiques ou numériques sans blanc (mettre le tiret _ entre deux chaînes). Il ne doit pas commencer par un caractère numérique. Cette remarque est valable pour les déclarations de constantes et de fonctions.

Signalons que le TURBO-PASCAL ne fait pas la différence entre majuscules et minuscules.

Les noms et types des variables sont déclarées sous la rubrique VAR.

Les types prédéfinis de base sont : integer (entier signé), real (réel), char (caractère), boolean (vrai/faux) et
array (tableau de valeurs indexées). La connaissance du type permet au logiciel de réaliser une gestion de la mémoire et une vérification syntaxique des instructions du programme.

3.1 Syntaxe d'une déclaration de variable : 

VAR identificateur : TYPE de la variable;

3.2 Syntaxe d'une affectation de variable : 

Pour attribuer une valeur ou une expression à une variable, on écrit : identificateur := valeur ;

On peut regrouper les variables de même type en les séparant par une virgule.

4 Types 

Un type est l'ensemble des valeurs que peut prendre une variable. Il y a trois grandes classes de types : les types scalaires, les types structurés, et le type pointeur que nous n'utiliserons pas.

En Pascal, les types prédéfinis de base sont : integer (entier signé), real (réel), char (caractère), boolean (vrai/faux) et array (tableau de valeurs indexées). La connaissance du type permet au logiciel de réaliser une gestion de la mémoire et une vérification syntaxique des instructions du programme.

4.1 Syntaxe d'une déclaration de type: 

TYPE identificateur = "définition ";

La partie "déclaration" permet à l'utilisateur de définir ses propres types sous la forme "Type nom = définition; " où le nom et la définition sont fixés par l'utilisateur . Ces nouveaux types sont alors utilisables pour les variables et dans le paramétrage des sous programmes que l'on déclare.

Exemple : Type montab= array[1..10] of integer; {définit un tableau d'entiers indexés de 1 à10}

5 Constantes 

Une donnée qui conserve la même valeur tout le long du programme peut être déclarée sous la rubrique CONST.

Syntaxe d'une déclaration et d'affectation de constante :

CONST identificateur = valeur ; (noter la différence = à la place de :=)

6 Entrée et sortie des données 

On utilise les instructions READ, READLN, WRITE, WRITELN qui sont des procédures prédéfinies du Pascal.

6.1 Entrées 

Lorsque une donnée doit être introduite par le clavier, on utilise la commande READ(nom) ou READLN(nom) qui lit et affecte la valeur lue aux variables concernées (ici identifiées par nom).

La procédure standard d'entrée est READLN(x).
Elle donne comme contenu à la variable x la valeur entrée au clavier.
L'entrée au clavier se termine par l'appui sur la touche "return" (ou"entrée") qui provoque à l'écran un retour chariot (d'où le suffixe ln).

Si la valeur entrée est incorrecte, une erreur se produit à l'exécution. Il est possible également d'utiliser la procédure READLN avec plusieurs paramètres, mais les risques d'entrée incorrecte, et donc d'erreur à l'exécution ne sont pas négligeables.

6.2 Sorties 

Pour l'affichage de messages ou de contenus de variables ou de valeurs de fonctions, on emploie la commande WRITE('message',nom) ou WRITELN('message',nom) .

Les commandes READLN( ) et WRITELN( ) jouent les mêmes rôles que READ( ) ET WRITE( ), en activant le curseur à la ligne suivante. Cela permet de disposer clairement des résultats. La procédure WRITE(x) écrit à l'écran le contenu du paramètre x. Le paramètre x peut être de type entier, réel ou chaîne de caractère (c'est simplement une suite de lettres encadrée par des apostrophes qui sera reproduite telle quelle à l'écran).Le paramètre peut être suivi d'une instruction de formatage séparée par deux points. Cette instruction de formatage indiquera au programme quelle est la taille minimale que doit prendre l'affichage à l'écran (c'est utile pour avoir de beaux alignements). Pour les nombres réels, on peut faire suivre d'une deuxième instruction de formatage (encore séparée par deux points) indiquant le nombre de chiffres aprés la virgule qu'il faut afficher.

Exemples:

Si x est une variable entière dont la valeur est 18, alors write(x) affichera '18'.

write(x:4) affichera ' 18' c'est-à-dire 18 précédé de deux espaces (de façon à former une chaîne de 4 caractères)

Si y est une variable réelle dont la valeur est 123,1234567890123 alors write(y) affichera ' 1.2312345678E+02' (soit un espace, le signe représenté ici par un espace, un chiffre avant la virgule, 10 chiffres après la virgule, suivi de la puissance de 10 indiquée par le symbole E)

write(y:20) écrira la même chose précédée de deux espaces supplémentaires.

write(y:9:5) affichera '123.12345'.

7 Les instructions 

Chaque instruction peut être soit une instruction élémentaire, soit une instruction composée, soit une instruction répétitive, soit une instruction conditionnelle.
Une instruction élémentaire peut être soit une affectation, soit un appel de procédure.

7.1 L'affectation : 

A tout instant, les variables ont un contenu qui peut être utilisé dans toute expression simplement à l'aide du nom de la variable, ce contenu peut être modifié par une nouvelle affectation. L'affectation est notée := .

Avant sa première affectation, le contenu d'une variable est indéterminé.
L'affectation générale a la forme " variable:=expression ;"(le tout devant être compatible en type).
Elle donne à la variable comme contenu la valeur de l'expression.

7.1.1 Expressions, Opérateurs 

Les ingrédients d'une expression sont des constantes, des nombres, des variables ou des fonctions assemblées par des opérateurs

- réels:
+ (addition), - (soustraction) * (multiplication), / (division)
- entiers :
+ (addition), - (soustraction) * (multiplication ) , div (quotient de la division euclidienne)
mod (reste de la division euclidienne)
- logiques :
not (négation), and ( "et" logique), or ("ou" logique)
- de comparaison :
= , < , > ,< > (différent) , > = ,< = (comparent deux nombres réels ou deux nombres entiers et renvoient true ou false comme résultat suivant que la relation en question est vraie ou fausse).

Exemples :
Expression : a + exp(2*pi*x[i]/13) ( a , x et i sont des variables, pi est une constante , 2 et 3 sont des nombres et exp est une fonction ).

Comparaison : si a et b sont de type real , a > b vaut true si (contenu de a) > (contenu de b)
et false si (contenu de a) <= (contenu de b).

Les règles habituelles de priorité des opérations jouent à plein, mais il est conseillé de ne pas être avare de parenthèses pour faciliter la lecture des expressions.

7.2 Appel de procédure 

On passe le contrôle du programme de façon temporaire à un autre bloc.

7.3 Instruction composée 

On peut assembler des instructions (élémentaires on non) par les deux mots begin et end.
L'ensemble obtenu est alors vu comme une unique instruction.

On obtient une instruction de la forme

begin
instruction1;
..................
instructionN;
end;

où instruction1, ... instructionN sont elles mêmes des instructions (simples, composées, répétitives ou conditionnelles). Les instructions sont séparées par des points-virgules.

7.4 Instruction conditionnelle 

Une instruction conditionnelle offre un choix à l'utilisateur.

Elle est de la forme :

if condition
then
instruction1
[ else
instruction2 ]

ici condition est une expression à valeur booléenne, instruction1 et instruction2 sont elles mêmes des instructions (simples, composées, répétitives ou conditionnelles). La partie " else instruction2" est facultative,
c'est la signification des crochets, les crochets eux-mêmes ne devant pas être tapés.

Si la condition est vraie le programme exécute instruction1 sinon il effectue instruction2 (ou rien si la partie "else..." est absente). Ceci correspond à la structure si ... alors ... sinon ..., de notre langage de formulation d'algorithmes.

Il ne doit jamais y avoir de point-virgule avant un then ou un else.

7.5 Instruction répétitive: 

Il existe en Pascal trois types d'instructions répétitives correspondant aux trois structures de notre langage de formulation d'algorithmes :

7.5.1 tant que... faire ..., 

Ce premier type " while condition do instruction "effectue l'instruction (simple, composée, répétitive ou conditionnelle) tant que la condition est vraie.(si au départ la condition est fausse instruction n'est jamais exécutée)

7.5.2 répéter... jusqu'à ce que ... , 

Ce deuxième type

repeat
instruction1;
....................
instructionN;
until condition

exécute la suite d'instructions (simples, composées, répétitives ou conditionnelles) séparées par des points-virgules jusqu'à ce que condition soit vraie. La suite d'instructions est toujours exécutée au moins une fois.

7.5.3 pour ... de ... à ... faire ... . 

Ce troisième type admet deux variantes (une montante et une descendante).

La première variante "for variable := expression1 to expression2 do instruction "
exécute l'instruction (simple, composée, répétitive ou conditionnelle) en donnant successivement à la variable les valeurs expression1, expression1 +1, expression1 +2,...., expression2.
(l'instruction n'est jamais exécutée si expression2 > expression1). Expression1 et expression2 sont des expressions à valeurs entières, variable est une variable, locale au bloc, de type entier, non modifiable par le programme au cours de la boucle.

La deuxième variante "for variable := expression1 downto expression2 do instruction"
fait la même chose mais en descendant, la variable prenant successivement les valeurs expression1, expression1 -1 , expression1 -2,...., expression 2 (l'instruction n'est jamais effectuée si expression2 < expressionl ).

Les instructions répétitives du type" for ... to ... do ..". sont réservées aux cas où l'on sait par avance comment doit varier l'indice entier qui ne devra pas être modifié par affectation au cours de la boucle.
Dans tous les cas où on désirerait manipuler cet indice au cours de la boucle, on utilisera à la place une instruction "while".

Exemple :
l'instruction
for i:= expression1 to expression2 do instruction {A la fin de l'exécution la valeur de i est expression2.}
est presque équivalente à
begin
i :=expression1
while i <= expression2 do
begin
instruction;
i:=i+1;
end;
end;
{ A la fin de l'exécution la valeur de i est expression2 + 1}

8 Les sous programmes 

L'analyse d' un problème à traiter conduit le plus souvent, à le fractionner en problèmes indépendants, et à faire traiter chacun de ces problèmes par un module spécifique. Chacun de ces modules s'appelle un sous-programme.

Les avantages des sous-programmes sont multiples:

ils permettent de décomposer un problème en problèmes plus simples (c'est l'analyse descendante). Si leurs noms sont bien choisis, ils accroissent la lisibilité du programme,et peuvent être utilisés à plusieurs endroits dans un même programme sans avoir besoin d'être réécrits.

Ils peuvent être réutilisés dans d'autres programmes s'ils sont réellement indépendants du reste du programme
(c'est ce qu'on appelle la modularité; elle est facilitée par l'usage des variables locales qui évite tout conflit de nom).

Il faut utiliser au maximum les sous-programmes.

Le corps d'un bloc ne devrait jamais dépasser une page écran (20 à 25 lignes); au delà, il devient souhaitable de le décomposer en sous programmes.

Un sous-programme peut recevoir des entrées ( paramètres du sous-programme) et éventuellement avoir une sortie (résultat). Les sous programmes ayant un résultat directement exploitable sont des fonctions, les sous-programmes sans sortie directe de résultat sont des procédures.

Ce qui est souhaitable:
un sous programme doit avoir un seul type d'action.
une fonction ne doit pas avoir d'action (son seul but doit être de retourner un résultat).

8.1 Variables locales, variables globales. 

Les sous programmes (fonctions ou procédures) peuvent faire intervenir deux sortes de variables :

Les variables introduites et déclarées à un niveau supérieur et utilisables globalement dans tout le programme principal.
Ce sont les variables dites globales.

Les variables créées dans le corps même du sous programme et qui ne sont utilisables qu'à l'intérieur de ce sous programme.
Ces variables sont totalement ignorées à l'extérieur du sous programme considéré. Ces variables sont dites locales.

Remarque : plusieurs variables peuvent ainsi partager le même identificateur dans un programme. Il n'y a pas de conflit car dans un bloc de sous programme, c'est la variable déclarée localement, qui masque une éventuelle variable de même nom déclarée à un niveau supérieur.

8.2 Les paramètres 

Ce sont les arguments fournis au sous-programme pour fonctionner. Ces paramètres peuvent être des valeurs ou des variables. Lorsqu'un paramètre est passé par valeur (ce qui est le mode par défaut), une variable locale est créée dans le sous programme dans laquelle est recopiée la valeur du paramètre. Une modification de la variable locale à l'intérieur du sous programme ne se répercute pas sur le paramètre passé.

Exemple :

procedure NeFaitRien(x:integer) ;
begin
x:=1;
end;

Si a est une variable du programme principal, l'appel de la procédure NeFaitRien(a) ne change pas la valeur de a. En fait le tout est équivalent à :

procedure NeFaitRien;
var x:integer;
begin
x:=a;
x:=1
end;

C'est la variable x dans laquelle a été recopiée la valeur de a qui est modifiée et pas la variable a.

Lorsque le paramètre est passé par variable (ou par référence) ce qui s'indique par le préfixe var , la variable locale créée à l'intérieur du sous programme a la même adresse que le paramètre passé, si bien que toute modification de la variable locale se répercute automatiquement sur le paramètre

Exemple :

procedure MetA1 (var x: integer)
begin
x:=1
end;

Lors de l'appel de MetA1 (a) une variable x ayant même adresse que la variable a, est créée dans le sous programme. Quand le contenu de x est mis à 1 , le contenu de a aussi.

Remarque : On peut évidemment passer par valeurs des nombres,des constantes ou des variables, mais on ne peut passer par variables que des variables. Dans un passage par variables, les types doivent être strictement les mêmes.

Dans un même sous programme, il peut y avoir des paramètres passés par variables, d'autres par valeurs.

8.3 Action des sous programmes. 

Un sous programme peut agir
- sur les paramètres passés par variables pour en modifier la valeur
exemple1 : readln qui est une procédure standard du Pascal qui entre dans une variable une valeur lue au clavier.
exemple2 :

procedure ECHANGE( var x , y :integer);
var z : integer
begin
z:=y;
y:=x;
x:=z;
end;

- sur les variables globales pour en modifier la valeur
Il s'agit d'une action à contrôler précisément et qui est souvent un obstacle à la modularité.
- sur l'environnement et en particulier sur les périphériques : écriture sur l'écran, émettre un bip, etc.
exemples :
la procédure writeln qui est une procédure standard du Pascal qui écrit sur l'écran le contenu d'une variable.
la procédure readln utilisée sans paramètre qui permet de réaliser une pause dans l'écran de sortie des résultats.

8.4 Résultat d'une fonction 

La fonction doit stocker son résultat dans une variable locale portant le nom de la fonction. Cette variable est une fausse variable qui ne peut servir qu'à être affectée (on ne peut pas évaluer son contenu).Elle n'a pas à être déclarée dans le sous programme ailleurs que dans l'en-tête.

exemple :

function ESCL96(x : real) : real ;
begin
x :=exp(x);
ESCL96:=x/(1+sqr(x));
end;

La variable ESCL96 est une variable locale au sous programme qui sert à transmettre le résultat de la fonction (et qui ne peut servir qu'à cela). Elle n'est pas déclarée dans le sous-programme, ailleurs que dans l'en-tête.

En TurboPascal, le résultat d'une fonction ne peut être que d'un type simple (real, integer ou boolean ou équivalent), mais ne peut pas être un tableau (array). Pour calculer un tableau, il faut utiliser un passage par variable.

8.5 Syntaxe de déclarations des sous programmes 

Chaque sous-programme correspond à un bloc. Sa structure est identique à celle du programme avec toutes ses déclarations. (Il peut lui même contenir des déclarations locales de type, const, var, function, procedure).

La déclaration du sous-programme se fait dans l' en-tête de son bloc par l'une des deux possibilités.

procedure NOM([Var] param1 ,...,paramN : type1;.... ;[Var] paramP ,...,paramQ :typeR );

function NOM([Var] param1 ,...,paramN :type1;.... ;[Var] paramP ,...,paramQ :typeR): typefn;

Le terme var entre crochets est facultatif. Lorsqu'il est présent, il indique que les paramètres sont passés par variables, donc susceptibles de se trouver modifiés par le sous programme. Typefn est un type simple (real, integer, boolean ou équivalent).

9 Les fonctions usuelles pour le calcul scientifique. 

Ce sont principalement les fonctions mathématiques.

abs(x: integer) :integer ; ou abs(x: real) :real; qui retourne la valeur absolue du paramètre.
int(x : real ): real ; qui retourne si x est positif, la partie entière de x et si x est négatif, l'opposé de la partie entière de -x.
Cette fonction ne coïncide pas avec la fonction mathématique usuelle notée E(x) ou [x] pour x négatif.
En l'utilisant avec x de type integer la fonction int peut servir à convertir un entier en réel
frac(x:real) : real ; qui retourne la partie fractionnaire de x , c'est-à-dire x-int(x).
trunc(x:real) : integer ; même chose que int mais le résultat est entier
round(x:real): integer ; retourne x arrondi à l'entier le plus proche
sqr(x : real) :real; retourne le carré de x
sqrt(x:real):real; retourne la racine carrée de x
exp(x:real) : real ; retourne I'exponentielle de x
ln(x:real) : real ; retourne le logarithme népérien de x
sin(x:real):real ; retourne le sinus de x
cos(x:real): real ; retourne le cosinus de x
arctan(x :real) :real ; retourne l'arc tangente de x
random:real ; fonction sans paramètre qui retourne un nombre au hasard dans l'intervalle [0 , 1[
random (x:integer) :integer ; retourne un nombre entier au hasard dans l'intervalle [0 , n-1]
randomize; procédure qui initialise le générateur de nombres aléatoires.
Avec les fonctions random les nombres pris au hasard ne seront vraiment pris au hasard que si au début du programme vous appelez la procédure randomize qui initialise le générateur de nombres aléatoires. Sinon, à chaque exécution du programme, la même suite de nombres aléatoire sera engendrée.
odd(n:integer) : boolean; retourne true si n est impair et false sinon.
chr(n:byte) : char ; retourne le caractère dont le rang dans le code ASCII est n
ord(x:char) : byte; retourne le rang du caractère x dans le code ASCII.
length(c:string ): integer; retourne la longueur effective de la chaîne c.

Remarques :

Toute erreur dans l'utilisation de ces fonctions (comme par exemple, un débordement dans l'usage de l'exponentielle ou la recherche du logarithme d'un nombre négatif) provoquera une erreur à l'exécution.

Le calcul des puissances (même entières) d'un réel ne fait pas l'objet d'un opérateur ni d'une fonction prédéfinie du TurboPascal. Il faut donc créer la fonction adaptée en cas de besoin.

Bibliographie

D. Monasse Mathématiques et informatique - Cours et TD - Edition Vuibert

Le livre de TURBO PASCAL (ver 4) F.Blanc et P. Brandeis . Edition P.S.I.