CODINGCLASSEURS WEKA ★ Comment exploiter toutes les ressources et augmenter les performances de votre AMSTRAD CPC ★

4/4.2 La programmation structurée en PASCAL|1er Complément)Coding Classeurs Weka

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.

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

; var

;

< déclaration d'une ou plusieurs procédures>;

< 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éri-

phé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 I 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) 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 à (tes 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.

Nous aurons par exemple :

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

real

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

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

Nous aurons par exemple :

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 Nous aurons par exemple :

Var Nom :string[15];

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.

Nous aurons par exemple :

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

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

Var resl : 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[15];
Adresse : string[30];
Téléphoné: string[ 11 ];
Age : integer;
end.

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' , 0'..'9'];

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[15];
Prénom : string[15];
Adresse : string[30];
Téléphoné: string[11];
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_amis record
Nom : string[15];
Prénom : string[15];
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çon suivante :

type
mois_de_l'annee = (Janvier,Fevrier,Mars, Avril, Mai, Juin, Juillet,Août,Septembre,Octobre,Novembre,Décembre) ;

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

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

type
courte_chaine = string[20];
longue_chaine = string[80];
table_1 = array [1..10] of integer;
table_2 = array [1..10, 1..5] of courte _chaine;

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 de base :

Pi3.1415926536 E + 00type Real
False Faux type Boolean
True Vrai type Boolean
Maxint 32767 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 > : ctype 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 2e 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 !).

Page précédente : 4/4.1 - Pourquoi utiliser le Turbo PASCAL et dans quels domaines

CPCrulez[Content Management System] v8.7-desktop/cache
Page créée en 147 millisecondes et consultée 335 fois

L'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent  du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko.