Algorithmique impérative/Pascal

Voici un guide de traduction d'un algorithme impératif en Pascal.

Algorithmique impérative
PyQt
PyQt
Sommaire
Théorie de l'algorithmique impérative
  1. Qu'est ce qu'un algorithme impératif Fait à environ 50 %
  2. Les types, les opérateurs et les expressions Fait à environ 50 %
  3. Les constantes, les variables Fait à environ 50 %
  4. Les instructions, les blocs d'instructions Fait à environ 50 %
  5. L'assignation Fait à environ 50 %
  6. Les exécutions conditionnelles Fait à environ 50 %
  7. Les structures itératives Fait à environ 50 %
  8. Les tableaux Fait à environ 50 %
  9. Les procédures et les fonctions Ébauche
  10. Le type enregistrement Fait à environ 50 %
  11. L'algorithme au final : vue d'ensemble En cours
  12. Exercices En cours
Outils de travail
Problèmes posés, analysés, résolus et commentés
Annexes
Modifier ce modèle ce sommaire

Le Squelette

modifier

Pour le squelette de l'algorithme :

Algorithme mon_algo

Constantes

Types

Variables

Début

Fin

On traduit ainsi :

program mon_programme;

Const

Type

Var

begin

end. (* notez ce point *)

Commentaires

modifier

Les commentaires notés

(* un commentaire *)

s'écrivent de la même façon

(* un commentaire *)

Voici l'équivalence des types

type Pascal
booléen bool
entier integer
réel real
caractère char
chaîne de caractères string
  • Les valeurs booléennes sont true et false.
  • Les parties entière et décimale d'un réel sont séparées par un point et non une virgule.
  • les chaînes sont déclarées entre deux apostrophes ' pour échapper un caractère on le double.

Exemple sur ce dernier point : pour inclure une apostrophe dans une chaîne,

writeln('l''apostrophe s''est échappée')

affiche

l'apostrophe s'est échappée

Constantes et variables

modifier

Les constantes et les variables ont des identifiants qui doivent respectées une syntaxe précise.

  • l'identifiant ne peut comporter que des caractères alpha-numériques (de A à Z, de a à z et de 0 à 9) et des tirets-bas ou underscore : _.
  • le premier caractère est une lettre.

les variables sont déclarées dans le Lexique du programme délimité par sa partie Var. Chaque déclaration est de la forme

identifiant : type;

Ainsi le lexique

Lexique
  un_reel : réel                     (* un réel quelconque *)
  une_chaine : chaîne de caractères  (* une chaîne quelconque *)

se traduit

Var
  un_reel : real;       (* un réel quelconque *)
  une_chaine : string;  (* une chaîne quelconque *)

Les accents ne sont généralement pas acceptés par les compilateurs Pascal.

Les identifiants des constantes respectent les mêmes règles. Par convention, on préférera les noter en majuscules. La déclaration d'une constante a pour syntaxe

 identifiant = valeur;

Ceci

Constantes
  PI = 3,14
  G = 9,81

s'écrit en pascal :

Const
  PI = 3.14;
  G = 9.81;

Instructions et blocs d'instructions

modifier

Pour exécuter une instruction (assignation, appel de fonction ou procédure) il suffit de l'écrire. Les paramètres sont précisés entre parenthèses et séparés par des virgules.

Les bloc d'instructions débutent par un begin et se terminent par un end. Les instructions du bloc sont séparées par des point-virgules. On gardera la convention algorithmique préférant une instruction par ligne.

Voici une ligne comportant une instruction unique :

une_instruction

Voici un bloc de k d'instructions :

begin
  instruction_1;
  instruction_2;
  (* ... *)
  instruction_k
end

Remarquez qu'aucun point-virgule ne ponctue la dernière instruction. En effet le ';' est un séparateur : il sépare les instructions entre elles. Il n'y a donc pas de point-virgule après la dernière instruction, pas plus qu'il n'y en a avant la première. Cela explique également pourquoi lorsqu'on écrit une seule instruction, elle n'est pas suivie d'un point-virgule.

Il est souvent affirmé à tort que « toutes les instructions se terminent par un point-virgule ». Ce n'est pas tout à fait vrai, comme nous venons de le voir. Cependant, cette croyance répandue a été prise en considération par les développeurs des compilateurs qui ignorent cette erreur.

Il convient de remarquer que le programme principal est un bloc d'instructions ponctué d'un point, ni plus ni moins.

Lecture et Écriture (affichage)

modifier

L'affichage s'effectue à l'aide de la procédure write. Elle peut prendre de un à plusieurs paramètres de n'importe quel type de base. Elle affiche tous les paramètres les uns après les autres (résultat identique à celui d'une concaténation).

Il existe une variante de write ayant la même spécification mais effectuant un retour à la ligne à la fin : il s'agit de la procédure writeln. On peut également appeler la procédure writln sans préciser de paramètres, cela effectue un retour à la ligne.

La lecture se fait à l'aide de la fonction read() qui prend en paramètre l'identifiant de la variable qui sera assignée.

readln est indentique à read() mais fait un retour à la ligne une fois la donnée lue.

Exemple

begin
  write('abc');
  write('def');
end

affiche

abcdef

alors que

begin
  writeln('abc');
  write('def');
end

affiche

abc
def

Assignation

modifier

L'assignation est une instruction et à ce titre elle doit respecter les règles sur les instructions (points-virgules...)

L'opérateur d'assignation est := (et non = qui est le test d'égalité)

La syntaxe de l'assignation est (espaces facultatifs) :

identifiant := expression

Il va sans dire que le type de l'expression doit être compatible avec celui de la variable assignée.

Exécution conditionnelle

modifier

On rappelle qu'une exécution conditionnelle est une instruction. Elle ne comporte pas de point-virgule sauf si elle est à l'intérieur d'un bloc. On suppose ici que l'instruction est au sein d'un bloc.

si condition alors instruction

donne

if condition then instruction;

S'il y a plusieurs instructions, on utilise un bloc :

if condition then begin
  instruction_1;
  instruction_2;
  instruction_k;
end;

Avec une instruction à exécuter quand la condition est fausse (sinon) :

si condition
  alors instruction_1
  sinon instruction_2

se traduit

if condtion
  then instruction_1
  else instruction_2;

De même on peut utiliser des blocs :

if condition then begin
  instruction_1;
  instruction_2;
  instruction_k;
end
else begin
  instruction_3;
  instruction_4;
  instruction_l;
end;

Structures itératives

modifier

Une boucle à compteur

POUR i de deb à fin faire instruction

donne

for i:=deb to fin do instruction;

On peut toujours utiliser un bloc comme instruction pour grouper plusieurs instructions à exécuter :

for i:=deb to fin do begin
  instruction_1;
  instruction_2;
  instruction_k;
end;

De même, une boucle répétée jusqu'à ce qu'une condition soit vraie (testée après chaque itération) :

repeat
  instruction
until condition;

et une boucle répétée tant qu'une condition est vraie (testée avant chaque itération) :

while condition do
  instruction
end;

Tableaux

modifier
lexique
  tab : tableau de deb à fin de T

donne :

var
  tab : array [deb..fin] of T;

Par exemple un tableau de 10 entiers, indicé de 1 à 10 :

var
  tab : array [1..10] of integer;

Procédures et fonctions

modifier

Le type enregistrement

modifier
type T = enregistrement
  champ : type_champ
fin

donne

type T = record
  champ : type;
end;

Exemple :

type WikilivreInfo = record
  titre : string;
  nombre_de_pages : integer;
  en_vitrine : boolean;
end;