4/4.2 la programmation structurée en pascal

Turbo PASCAL : Définitions et rappels de base Partie 4 Chapitre 4.2 page 1

Partie 4 : Langages du CPC

4/4.2

La programmation structurée en PASCAL

Dans ce chapitre, nous allons étudier :

— la structure d'un programme écrit en Turbo PASCAL (I),

— et, en détails, les concepts évolués du langage (II).

Le premier volet de ces études est surtout réservé aux personnes qui ne connaissent pas le langage PASCAL. Nous y présentons tout ce qu'il est nécessaire de savoir pour débuter en PASCAL.

Le deuxième volet concerne tous les programmeurs qui, même s'ils ne débutent pas en PASCAL, ont quelques lacunes sur des concepts spécifiques comme, par exemple, utilisation des overlay, insertion de langage machine dans un programme PASCAL, manipulation de fichiers, etc. De nombreux exemples vous aideront à mieux appréhender ces divers problèmes.

I. Structure d'un programme écrit en Turbo PASCAL

La programmation en Turbo PASCAL se fait selon des règles bien précises que nous allons passer en revue. Les concepts manipulés par ces règles vont très loin. Leur but est de :

— planifier l'enchaînement logique d'actions élémentaires,

— augmenter la lisibilité des programmes,

— simplifier la maintenance et/ou la reprise des programmes.

Pour parvenir à de telles fins, un programme PASCAL est partitionné en plusieurs blocs :

— identification du programme par son nom (program),

— déclaration des étiquettes (label),

— déclaration des types (type),

— déclaration des constantes (const),

— déclaration des variables (var),

— déclaration des procédures et des fonctions,

— programme principal.

1er Complément

Partie 4 Chapitre 4.2 page 2 Turbo PASCAL : Définitions et rappels de base


Un programme typique écrit en PASCAL aura donc la structure suivante :

Program Mon_ premier__essai ;

label

<déclaration d'une ou plusieurs étiquettes>;

type

< déclaration d'un ou plusieurs types >;

const

< déclaration d'une ou plusieurs constantes >;

var

<declaration d'une ou plusieurs variables>;

< déclaration d'une ou plusieurs procedures >;

< déclaration d'une ou plusieurs fonctions>;

begin

< programme principal >

end.

Toutes les données qui sont utilisées dans les procédures, les fonctions ou le programme principal doivent être déclarés dans des blocs de déclaration (de labels, de type, etc.) selon l'ordre qui vient d'être donné. Cela peut vous sembler contraignant. En fait, vous vous apercevrez bien vite qu'il n'en est rien, et que le fait de bien définir le type des données manipulées vous fera gagner un temps précieux lors de la mise au point de vos programmes. C'est un des points forts du langage : avant d'utiliser une variable, il faut définir son type. Vous êtes donc obligé(e) de vous poser des questions sur cette variable, et sur l'utilisation que vous allez en faire. Cette démarche vous évitera en particulier de confondre deux variables, ou de faire des opérations concernant les chaînes sur une variable numérique ou inversement...

II. Les concepts évolués du Turbo PASCAL

Nous allons maintenant étudier dans chaque bloc les possibilités offertes par le Turbo PASCAL.

A. En-tête du programme

La première ligne d'un programme écrit en Turbo peut commencer par le mot « program » suivi d'un nom de programme, le plus explicite possible, afin d'avoir une idée de sa fonction par la seule lecture de l'entête. En Turbo, cette en-tête est facultative, mais nous vous conseillons cependant de la faire figurer dans vos programmes, ne serait-ce que pour



la raison qui vient d'être citée. N'hésitez pas à employer des noms assez longs. Au besoin, séparez les divers mots du titre par un caractère souligné (__). Si le programme doit communiquer avec un ou plusieurs périphériques, il(s) est (sont) indiqué(s) entre parenthèses derrière le nom du programme. Par exemple :

Program essai (input, output) ;

B. Etiquettes

Les étiquettes sont des noms alphanumériques qui servent à repérer une ligne de programme pour y accéder par l'instruction goto. Cette instruction ne doit être employée que dans les cas désespérés ! Si vous utilisez correctement les ordres structurés du Turbo (repeat, for do, while, case, etc.), vous pourrez sans doute éviter d'utiliser l'instruction goto, et le bloc de déclaration d'étiquettes sera donc vide.

Si malgré tout, vous désirez utiliser une ou plusieurs étiquettes, voici la façon dont il faudra vous y prendre :

Program test-etiquette ;

label

ici;

begin

writeln ('Cette ligne s'affichera une fois,');

ici :

writeln ('et celle-ci indéfiniment.');

goto ici;

end.

C. Types

En PASCAL, les variables doivent être identifiées selon leur type. Pour cela, il existe plusieurs types prédéfinis, et le programmeur peut également définir ses propres types de données.

Dans le premier cas, il suffira d'indiquer le type de donnée après chaque variable dans le bloc de déclaration des variables.

Dans le deuxième cas, il faudra en plus définir le ou les nouveau(x) type(s) dans le bloc de déclaration des types.

1 •' Complément



1) Types prédéfinis

Les types prédéfinis sont les suivants :

boolean

Deux valeurs : False et True.

Ce type concerne tous les tests logiques.

Nous aurons par exemple :

Var oui__ou__non : boolean;trouve : boolean;

char

Caractère. C'est une chaîne de longueur 1 caractère. Nous aurons par exemple :

Var lettre : char;

integer

Nombre entier compris entre - 32767 et 32767.

Une distinction est faite entre entiers et réels. La raison est liée à des contraintes technologiques qui font que les deux types de nombres ne sont pas représentés de la même manière en mémoire, et par là même, ils ne peuvent subir les mêmes opérations.


Var i,j : integer;début : integer;

real

Nombres réels compris entre - 1E37 et“1 E37

Ces nombres sont représentés en notation flottante de la manière suivante :


Var x, y : real; résultat : real;



string

Chaîne alphanumérique de longueur maximale 255 caractères.

Ces ordres de manipulations de chaînes sont :

Copy, Concat, Delete, Insert, Length, Pos, Str, Val


Var Nom : string[15J;

Prénom : string[15];

Adresse : string[80];

array

Un tableau est un ensemble de variables indicées de même type accessibles par un nom de tableau et un indice dans le tableau.


Var table : array [1..10] of real;

Type résultat : array [1..100] of integer;

Var res1 : résultat;res2 : résultat;

record

Un enregistrement est une structure de données constituée d'un nombre fixe de données hétérogènes appelées champs.

Reportez-vous à l'instruction « with » qui facilite la manipulation des variables de type record. (Voir Partie 4 chap. 4.3.)

Nous aurons’par exemple :

type mes__amis = record

Nom : string[15];

Prénom : string[1 5];

Adresse : string[3O];

Téléphoné: string[11);

Age : integer;

end;

1er Complément



set

Un ensemble est un regroupement de variables de même nature. Par exemple, nous pourrons définir l'ensemble des caractères alphanumériques comme :

type

Alpha = set of ['A'..'Z', 'a'./z', 'O'..'9'J;

D'une façon générale, un ensemble sera défini dans le bloc de déclaration des types par les mots-clés "set of", et réutilisé pour définir le type d'une ou plusieurs variable(s) dans le bloc de déclaration des variables.

file of

Un fichier est une collection de données du même type qui peuvent être manipulées en mémoire ou sur disque.

Pour pouvoir être manipulé, un fichier doit d'abord être défini dans le bloc de déclaration des types, puis affecté à une variable dans le bloc de déclaration des variables comme suit :

type

fichier = file of record

Nom : string[15J;

Prénom : string[15J;

Adresse : string[30J;

Téléphoné: stringfll];

Age : integer;

end;

var

ami : fichier;

Pour faciliter la manipulation des fichiers, des ordres spéciaux ont été implémentés dans le Turbo PASCAL. Il s'agit de : Assign, Close, Erase, Flush, Read, Rename, Reset, Rewrite, Seek, Write.

De même, des fonctions ont été créées. Il s'agit de : EOF, Filepos et Filesize.

Un pointeur permet de définir une variable dont la taille peut varier dans le temps : une variable (pointeur) contenant l'adresse d'une autre variable permet d'accéder à cette dernière.

Un pointeur devra être déclaré dans le bloc de déclaration des types en faisant référence à un autre type (souvent Record), puis être affecté à une ou plusieurs variables dans le bloc de déclaration des variables.



type

ptr = mes__amis;

mes__amie record

Nom : string[15];

Prénom : string[15J;

Adresse : string[30];

Téléphoné: string[11);

Age : integer;

end;

var

ptr__amis : p;

2. Types définis par l'utilisateur

intervalle

Ce type permet d'affecter un sous-ensemble ordonné d'ensemble déjà défini (mis à part l'ensemble des réels dont on ne peut extraire un sous- ensemble pour l'affecter à un type intervalle.) Nous aurons par exemple :

type lettre-majuscule = 'A'..'Z';

lettre-minuscule = 'a'..'z';

chiffre = '0'..'9';

mois = janvier..décembre;

scalaire

Un type scalaire défini par l'utilisateur (appelé scalaire déclaré) permet de définir des ensembles finis en indiquant, dans l'ordre, les éléments de cet ensemble.

Par exemple, nous définirons le scalaire mois__de__l'annee de la façonsuivante :

type

mois__de_J'annee = (Janvier,Février,Mars,Avril, Mai, Juin, Juillet, Août,Septembre,Octobre, Novembre,Décembre) ;

Les ordres Suce (successeur), Pred (prédécesseur) et Ord (valeur ordinale) sont appliquables à de tels types.

7er Complément



Toutes sortes de types peuvent être créés à partir des types de base. Par exemple, nous pourrons créer les types suivants :

type

courte__chaîne = string[2O];

longue__chaîne = string[80];

table 1 = array [1 ..10] of integer;

table 2 = array [1 ..10, 1..5] of courte chaîne;

D. Constantes

Les constantes sont des entités qui sont définies une fois pour toutes dans le bloc de définition des constantes, et dont la valeur ne peut être redéfinie dans le cours du programme.

Les constantes peuvent être des nombres entiers ou réels ou des chaînes de caractères.

<constante> = <valeur numérique ou alphanumérique>

Les quatre constantes suivantes sont définies dans le Turbo PASCAL debase :

Pi

False

True

Maxint

3.1415926536 E + 00

Faux

Vrai

32767

type Real

type Boolean

type Boolean

type Integer

E. Variables

Toute variable utilisée dans un programme, une procédure ou une fonction doit être déclarée dans le bloc de déclaration des variables. La déclaration consiste à donner le nom de la variable suivi de son type. Le type peut être un des types prédéfinis dans le Turbo PASCAL ou un type défini par l'utilisateur.

<nom de variable> : <type de la variable>

F. Procédures et fonctions

Une procédure est un programme à part entière et est définie dans un programme avant le premier begin. Une procédure peut posséder ses propres variables (variables locales) ou faire appel, et éventuellement modifier les variables du programme principal (variables globales). Une procédure est activée par son nom, à l'intérieur d'une autre procédure, d'une fonction ou du programme principal.

Une fonction est un programme à part entière dont le but est d'effectuer un ou plusieurs calcul(s) et de le(s) renvoyer dans une variable. Pour ce faire, une fonction (au même titre qu'une variable) possède un type :



le type de la valeur qui sera fournie en sortie. Une fonction est activée par son affectation à une variable du même type, à l'intérieur d'une procédure, d'une autre fonction ou du programme principal.

G. Programme principal

Il doit commencer par l'ordre « begin » et finir par l'ordre « end ». Il peut faire appel à toutes les procédures et fonctions définies dans le bloc précédent, et manipuler toutes les variables dont le type a été défini dans le bloc de déclaration des variables. Il peut également faire appel à toutes les variables et structures prédéfinies de Turbo PASCAL.

Normalement, le programme principal doit être très court. Il doit se contenter d'enchaîner logiquement les procédures et fonctions qui ont été définies précédemment sans descendre au niveau élémentaire (les procédures et fonctions sont là pour ça I).

1er Complément

4/4.2 la programmation structurée en pascal

Documents