INFORMATIQUE TURBO PASCAL -...

Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 1

INFORMATIQUE

TURBO PASCAL

Année 2004-2005

A.R. LIEGE 1


CHAPITRE I - INTRODUCTION

I.1. CHARGEMENT DU TURBO PASCAL

Le lancement du Turbo Pascal à partir de Windows 95 dépend de la configuration de celui-ci.

Si la barre des tâches a été correctement configurée, il suffit de cliquer successivement sur

Démarrer, Programmes, Borland Pascal et Bpw.

Cette version du Turbo Pascal peut fonctionner aussi bien dans un environnement Windows

que dans un environnement DOS. C’est le premier mode de fonctionnement qui est expliqué

dans les notes ci-dessous.

I.2. PRÉSENTATION TURBO PASCAL

En réalité, l'ordinateur place l'utilisateur dans un nouvel environnement : le mode d'édition de

programmes. Cet environnement se superpose, à l'écran comme en mémoire, au système

d'exploitation.

Le chargement est terminé lorsque l'écran suivant apparaît.


La première ligne est appelée la ligne des menus. Elle fera l'objet d'une étude détaillée dans le

paragraphe suivant.

Juste en dessous figure la barre d’icônes. Elle aussi fera l'objet d'une étude détaillée dans le

paragraphe suivant.

En dessous, il y a la fenêtre d'édition : c'est l'endroit où apparaîtra le listing du programme

qui sera dactylographié. Sur la première ligne de cette fenêtre, figure le nom sous lequel le

programme pourrait être sauvé. Le nom "NONAME00.PAS" est une proposition, pas une

obligation. Nous verrons comment changer ce nom si nécessaire.

Enfin, la dernière ligne est une ligne d'état. Elle rappelle à l'utilisateur la position du curseur

dans la fenêtre d’édition (numéro de ligne et de colonne) et le mode de dactylographie actif

(mode Insertion ou écrasement).

I.3. LA LIGNE DES MENUS

La ligne des menus a pour but d'aider l'utilisateur lors de la mise au point de son programme :

sauver le programme sur disquette et le récupérer; compiler le programme, système d'aide, ...

Voici une description des principales branches du menu.

1) File

Le menu "File" contient toutes les informations

relatives au fichier : récupération, sauvegarde,

impression,...

On active le sous-menu en cliquant sur “File” et on

obtient l'affichage ci-contre :

Pour activer une option parmi d'autres, il suffit de

cliquer sur la ligne correspondante.

Parmi les différentes options, celles-ci sont utiles :

(1) NEW : ouvre une nouvelle fenêtre pour qu'on

puisse y dactylographier un autre programme.

Le nom de la fenêtre se trouve dans le coin supérieur gauche de la fenêtre

d’édition. Pascal est capable de travailler sur plusieurs documents à la fois, mais un

seul est actif. Pour rendre un document actif, il suffit de cliquer dans la fenêtre son

bord supérieur. Pour fermer une fenêtre inutile, il suffit de cliquer dans le petit

carré contenant une croix dans le coin supérieur droit.


(2) OPEN : charge dans une nouvelle fenêtre un programme précédemment sauvé sur

la disquette ou sur le disque dur. L’icône est un raccourci permettant la même

action.

On a alors comme affichage la liste des noms des fichiers programmes Pascal

sauvés sur la disquette ou le disque dur (regarder la rubrique Path). Il suffit alors

de sélectionner le programme en cliquant sur son nom puis sur le bouton “OK”.

(3) SAVE : sauve le programme actuellement en mémoire en conservant le nom et le

lecteur d’origine. La sauvegarde est automatique -sans confirmation

supplémentaire-, elle attribue une nouvelle extension "BAK" à l'ancienne version

du programme et le programme en mémoire -nouvelle version- prend l'extension

"PAS" devenue libre. Ce système permet de conserver une copie du programme

après transformations. Cela peut s'avérer utile lorsque la nouvelle version du

programme est plus mauvaise que l'ancienne.

Attention, s'il s'agit du premier sauvetage, SAVE se transforme automatiquement

en SAVE AS.

L’icône permet la même action.

(4) SAVE AS : permet de sauver le programme en mémoire sous un nouveau nom ou

sur un autre lecteur. Si le programme n’a pas déjà été enregistré, cela permet de

choisir le nom et le lecteur de destination.


(5) SAVE ALL : sauve tous les programmes ouverts.

(6) PRINT : imprime le programme actif .

(7) EXIT : quitte le programme "TURBO PASCAL". Cela peut se faire à tout

moment en appuyant sur <Alt-F4>.

2) Edit

Le menu Edit contient toutes les commandes facilitant l'édition du texte :

(1) UNDO : restitue le texte dans l'état précédent la dernière modification du texte.

Pratique lorsqu'on a effacé une ligne à conserver,...

(2) REDO : exécute à nouveau la dernière modification apportée au texte.

(3) CUT, COPY et PASTE : ces trois commandes permettent de déplacer ou de

dupliquer un texte sélectionné.

Pour sélectionner un texte, on peut procéder de deux façons différentes :

- on se place au début du texte, on maintient la touche <Shift> enfoncée, et on

déplace le curseur vers la fin du texte à l'aide des flèches de direction,

- on se place au début du texte, on maintient le bouton gauche de la souris

enfoncé et on glisse vers la fin du texte.

Le texte sélectionné apparaît en contrasté.

La commande CUT enlève le texte sélectionné de l'écran et le place en mémoire,

COPY met le texte sélectionné en mémoire sans l'enlever de l'écran. PASTE fait

réapparaître le texte sélectionné à l'endroit où se trouve le curseur.

L'utilisation successive de CUT et PASTE permet donc de déplacer un texte, celle

de COPY et PASTE de le dupliquer.

Ces trois commandes sont présentes dans tous les traitements de texte.


Remarque : étant donné que Pascal est capable de travailler avec plusieurs fenêtres,

il est possible de copier un extrait d'un programme dans l'une et de le recopier dans

une autre.

(4) CLEAR : efface le texte sélectionné.

3) Search

Contient les commandes permettant l'automatisation de la correction de certaines

fautes : fonction de recherche d'un caractère ou d'une chaîne au sein du programme,

remplacement d'une chaîne par une autre,...

Ce type de commandes se trouvent également dans les traitements de texte.

4) Run

La commande Run déclenche l'exécution du programme en mémoire. Si celui-ci n'a pas

encore été compilé, déclenche d'abord la compilation.

5) Compile

La signification du concept de "compilation" fait l'objet d'un paragraphe suivant. Sans

approfondir, signalons qu'il s'agit de traduire le programme pascal en binaire, de telle

sorte que l'ordinateur puisse l'exécuter.

6) Help

Ce menu permet d'accéder au logiciel d'aide de Pascal.

I.4. LANGAGE COMPILÉ OU INTERPRÉTÉ

L'ordinateur ne comprend qu'un seul langage : le langage machine. Celui-ci est cependant

difficilement compréhensible pour l'homme, et d'autant moins maniable qu'il diffère d'un

microprocesseur à l'autre. Au cours des années, l'homme s'est efforcé de "faire comprendre" à

l'ordinateur d'autres langages, qui lui sont plus accessibles. On parle alors de langages

évolués : FORTRAN, COBOL, BASIC, PASCAL, C... sont les plus connus. Les plus récents

sont des langages orientés-objets : Visual Basic, C++, Java, ...

L'ordinateur traduit lui-même un langage évolué en langage machine grâce à un programme

écrit en langage machine. Au début de la micro-informatique, ce programme traducteur était

mémorisé dans la ROM des ordinateurs. C'était, dans la grande majorité des cas, un

programme de traduction de BASIC : un interpréteur. C'est ce qui explique que l'ordinateur

"connaissait" le BASIC dès qu'on allumait. Actuellement, ce même interpréteur est


généralement un programme sauvé sur disquette, que l'on charge en RAM uniquement en cas

de besoin. Il est alors fourni avec les disquettes DOS.

Pour d'autres langages, tel le Pascal, ce programme de traduction s'appelle un compilateur. Il

se trouve dans le fichier TURBO.EXE. L'ordinateur est incapable de comprendre un mot de

Pascal sans ce compilateur.

La différence entre un langage compilé et un langage interprété est la suivante. En BASIC,

dès l'envoi de l'ordre RUN par l'utilisateur, l'ordinateur lit la première instruction (instruction

source), la traduit grâce à l'interpréteur (instruction objet), l'exécute si elle est correcte (du

point de vue de la syntaxe ou des calculs) puis passe à l'instruction suivante s'il n'y a pas

d'erreur. Dès que l'ordinateur décèle une erreur, il affiche un message à l'écran et interrompt

l'exécution. Après correction, il faut relancer l'exécution pour que l'interpréteur recommence

le travail.

En Pascal, dès la demande d'exécution, le programme (appelé programme source) est

entièrement traduit (programme objet) par le compilateur, cette version traduite est

enregistrée sur disque (avec l’extension .exe), puis seulement exécuté si aucune erreur de

syntaxe n'est trouvée. Tant que des erreurs de syntaxe existent, l'ordinateur refuse d'exécuter

ne fût-ce qu'une partie du programme.

Remarque : on peut demander l’exécution d’un programme compilé (.exe) en cliquant deux

fois sur son icône, et cela, même sans avoir le Turbo pascal installé sur sa machine.

Au niveau de l'encodage du programme, l'interpréteur est plus souple que le compilateur car

plus interactif. Le compilateur est cependant meilleur quand il doit exécuter plusieurs fois le

même programme avec différentes données car la traduction n'est nécessaire qu'une seule

fois. De plus, l'exécution d'un programme est beaucoup plus rapide lorsqu'il s'agit d'un

langage compilé (car la traduction n'est jamais effectuée qu'une seule fois).

I.5. ERREURS DE COMPILATION

Lors de la compilation, Pascal vérifie si le programme a été correctement écrit. Il vérifie donc

l'ensemble des règles qui régissent la structure d'un programme. Dès qu'il découvre une

erreur, la compilation s'arrête. L'ordinateur affiche un message qui tente d'expliquer ce que

Pascal reproche au programme. Le curseur s'arrête après l'erreur (logique : il s'arrête dès qu'il


trouve la faute, donc après). Attention, il se peut que l'erreur se trouve bien plus haut dans le

programme.

Tous les messages sont numérotés. Les principaux sont les suivants :

N Message Explication probable

2 Identifier expected Omission d'un nom derrière un des mots

program, const, var, ...

3 Unknow identifier Utilisation d'une variable ou d'une constante non

déclarée,... La variable peut avoir été mal

orthographiée, ou déclarée à un mauvais endroit

(ex : dans le corps du programme)

4 Duplicate identifier L'identificateur déclaré est déjà utilisé.

5 Syntax error Utilisation de " dans write, de caractères

accentués dans un identificateur, ...

8 String constant exceeds line Chaîne de caractères trop longue. Souvent, oubli

de fermer une ' dans write.

10 Unexpected end of file Manque le "end." à la fin du programme

11 Line too long La ligne courante est trop longue. Seuls les 126

premiers caractères sont pris en compte.

26 Type mismatch Erreur de type : on donne à une variable une

valeur incompatible avec son type (valeur

caractère pour une variable réelle, réelle pour une

variable entière, ...)

36 Begin expected Oubli d'un begin (par ex : au début du corps du

programme).

37 End expected Oubli d'un end.

85 ';' expected Oubli d'un point-virgule entre deux instructions.

86 ':' expected

87 ',' expected

88 '(' expected

89 ")" expected Oubli de fermer la parenthèse dans les ordres

write, read, ou certaines fonctions (abs,...)

90 '=' expected

91 ":=" expected instruction d'affectation mal écrite.


94 "." expected Le dernier "end" est suivi d'un point virgule et pas

d'un point.

CHAPITRE II - LES BASES DE PASCAL

II.1. DÉFINITIONS

Un algorithme est une suite d'opérations résolvant un type spécifique de problèmes. Un bon

algorithme doit présenter les caractéristiques suivantes :

il doit être clair, facile à comprendre par tous ceux qui le lisent;

• il doit conduire à l'exécution d'un nombre fini d'opérations, ce nombre doit être, si

possible, réduit au minimum;

• chaque opération doit être définie avec précision (que faut-il faire ?, avec quoi ?,

comment ?,...) et être exécutable (pas de division par 0, pas de racine carrée de

nombre négatif,...);

• il doit produire des résultats;

• il doit garder la plus grande généralité possible;

• si possible, limiter la place occupée en mémoire.

Un programme est un ensemble d'instructions écrites en langage informatique et soumises

ensemble à l'ordinateur pour qu'il les exécute. C'est la traduction informatique d'un

algorithme. Les instructions d'un programme PASCAL sont exécutées dans l'ordre de lecture,

elles ne sont pas numérotées.

Un langage évolué, tel que le Pascal, se compose de plusieurs parties :

• l'alphabet : liste de symboles ou caractères utilisables;

• le vocabulaire : ensemble des mots, fabriqués à l'aide de l'alphabet, qui sont compris

par l'ordinateur ainsi que leur signification. Dans les notes qui suivent, ces mots, dits

réservés, sont écrits en minuscules et en lettres grasses; on dit que ces mots sont

réservés ;

• l'orthographe : ensemble des règles qui codifie la façon d'écrire les mots du

vocabulaire;

• la syntaxe : ensemble des règles qui permettent de combiner les caractères de

l'alphabet et les mots du vocabulaire. Par exemple, toutes les instructions de Pascal

sont séparées par un ";".


II.2. STRUCTURE D'UN PROGRAMME PASCAL

En Pascal, un programme commence toujours par la déclaration

program <nom_du_programme>;

où <nom_du_programme> est une chaîne de caractères, commençant par une lettre, ne

comportant ni de "blancs" (espaces) ni de caractères accentués. Cette partie porte aussi le

nom d'en-tête. Juste après cette ligne, il est vivement conseillé d’ajouter l’instruction

« uses wincrt; »lorsqu’on utilise la version Windows.

Ensuite, on distingue, dans l'ordre, trois parties :

• la partie déclarative : qui permet de déclarer les renseignements indispensables sur les

grandeurs à utiliser (déclaration de type, de variable, de constantes,..);

• les sous-programmes : appelés procedure ou function; ils seront abordés plus

tard. Cette partie est facultative.

• le corps du programme : commence toujours par begin, est composé

d'instructions séparées par un ";" et se termine par end.

• Enfin, un programme PASCAL est toujours terminé par un point.

II.3. PARTIE DÉCLARATIVE

a) Les variables

1) Caractéristiques d'une variable

Pour effectuer les instructions qui lui sont soumises, l'ordinateur aura besoin de

mémoriser les grandeurs qu'il doit utiliser. Pour cela, on a besoin de variables ou de

constantes, elles peuvent représenter des données, des inconnues, des compteurs,... Les

variables sont caractérisées par plusieurs éléments :

• type : scalaire, tableau, texte, logique... La définition du type d'une variable est

extrêmement importante car elle détermine non seulement l'ensemble des

valeurs qu'elles peuvent prendre mais aussi le codage de la valeur de la

variable (nombre d'octets).

• nom : appelé identificateur. Il permet de distinguer des variables distinctes;

• adresse : endroit de la mémoire où est codée la valeur.

On peut comparer l'ordinateur à un vendeur de chaussures et sa mémoire aux étalages

dont le vendeur dispose. Le type de la variable permet de voir s'il s'agit de chaussures

de ville, de marche, de sport..., l'identificateur joue le rôle de la marque de chaussures,

la valeur de la variable étant la paire de chaussures.


L'identificateur des variables commencent par une lettre qui peut être suivie par un

nombre quelconque de lettres ou de chiffres (ne pas utiliser les caractères accentués, les

signes de ponctuation, ...).

On peut également écrire un identificateur en deux mots à condition de les relier par un

"_" comme ci-dessus. Cependant, la plupart des compilateurs ne distinguent pas deux

identificateurs dont les huit premiers caractères sont semblables.

2) Types de variables

Il existe deux catégories de types de variables en Pascal : les types prédéfinis et les

types composés. Les types prédéfinis sont ceux qui n'exigent pas de déclaration

particulière, les types composés sont ceux qui peuvent être fabriqués à partir des types

prédéfinis moyennant une déclaration de type : les possibilités sont illimitées. Les types

composés seront abordés ultérieurement.

Parmi les types prédéfinis, on distingue les types simples et les types structurés. Les

types simples sont ceux qui concernent des variables ne contenant qu'un seul élément.

Par exemple :

• INTEGER : nombres entiers;

• REAL : nombres réels;

• BOOLEAN : variables logiques; une variable booléenne peut prendre pour

valeur vrai ou faux (true et false).

• CHAR : caractère (variable alphanumérique).

On dispose aussi de types structurés dont principalement :

• ARRAY : vecteurs et matrices;

• STRING : chaînes de caractères (variable alphanumérique);

• SET : ensemble;

• FILE : fichier;

• RECORD : enregistrement (permet de définir les types composés).

3) Variables numériques

Il y a deux grandes familles de variables numériques : les variables entières et les

variables réelles.

Une variable entière peut prendre pour valeur tous les nombres entiers compris entre -

32768 et 32767 (un entier est codé sur deux octets -16 bits-, on peut donc mémoriser

216 = 65536 valeurs différentes).


PASCAL admet des variantes du type entier :

• courts : SHORTINT = entiers compris dans [-127,128] (codée sur un octet);

• longs : LONGINT = entiers compris dans [-2147483648, 2147483647];

• octets : BYTE = entiers compris dans [0,255]) (codée sur un octet);

• mots : WORD = entiers compris dans [0,65535]) (codée sur 2 octets).

Une variable réelle peut prendre pour valeur tous les nombres réels (un réel est codé sur

5 octets, il peut prendre les valeurs dans l'ensemble {-1038, -10-38} ∪ {0} ∪ {10-

38,1038}. Il existe aussi d'autres catégories de nombres réels :

• simple : SINGLE = réels dans [1.5 10-45,3.4 1038];

• double : DOUBLE = réels dans [5.0 10-324,1.7 10328];

• étendu : EXTENDED= réels dans [1.9 10-4951, 1.1 104932]

Ces derniers types de réels exigent cependant la présence d'un coprocesseur

mathématique ou de directives de compilation faisant croire que le coprocesseur est

installé.

4) Variables alphanumériques

On appelle variable alphanumérique les variables pouvant prendre pour valeur un ou

plusieurs caractères qu'ils soient numériques (les opérations arithmétiques n'étant pas

valables dans ce cas) ou autres. En fait, il s'agit de tous les caractères utilisés en

informatique et qui sont répertoriés dans le code ASCII.

Selon le nombre de caractères que les variables alphanumériques peuvent contenir (1

ou plusieurs), on distingue deux types de variables alphanumériques : les caractères

(CHAR) et les chaînes de caractères (STRING).

5) Déclaration d'une variable

La déclaration des variables se fait en début de programme (dans la partie déclarative) à

l'aide de l'instruction var <nom_de_la_variable> : <type_de_la_variable>;

Le mot var n'est nécessaire qu'une seule fois pour toutes les variables. On peut déclarer

plusieurs variables d'un même type ensemble en les séparant par une virgule.

Exemple var X,Y : REAL;

A : INTEGER;

a,b,c : char;


Syntaxe1

Les différentes possibilités de déclaration de variables peuvent être représentées par le

dessin suivant :

var identificateur : type ;

b) Les constantes

Parfois, certaines données intervenant dans un problème sont invariables, constantes. Ainsi,

dans les recherches de surface ou de périmètre de cercle, de sphère ou de cylindre...

On peut déclarer le caractère constant de ces données par une déclaration de constantes. Cela

se fait à l'aide de l'instruction const <nom_de_la_constante> = <(ensemble) valeur_de_la_constante>;

Exemple const pi = 3.141592;

nom = 'DUPONT';

voyelle =['a','e','i','o','u'];

Syntaxe

La déclaration de constantes se fait dans la partie déclarative, après l'entête de

programme mais avant la déclaration de variables. Un même identificateur ne peut

évidemment pas être déclaré à la fois constante et variable. On représente cette

déclaration par le graphique ci-dessous.

const identificateur =

[ ]

valeur

valeur ,

, ;

Il est entendu que si <valeur> est un caractère ou une chaîne de caractères; chaque

valeur est entourée d'apostrophes (cfr. exemple).

1 Remarque : La structure et la syntaxe d'un ordre PASCAL seront souvent illustrées par un graphique. Pour en comprendre le

fonctionnement, il faut savoir que les mots ou signes écrits en gras et entourés d'un cadre épais doivent être dactylographiés exactement

comme signalés, ceux qui sont entourés d'un simple cadre dépendent du programmeur.


II.4. LE CORPS DU PROGRAMME

Le corps du programme est constitué d'instructions. Les premières instructions que nous

allons étudier sont les plus élémentaires.

a) Affecter une valeur à une variable

Cette instruction consiste à donner une valeur à une variable. En tant qu'instruction, elle se

trouve dans le corps du programme.

Syntaxe

L'assignation ou affectation en Pascal se fait comme le montre le diagramme suivant :

identificateur := valeur ;

Exemple x:=5; nom:='DUPONT'; reponse:=false;

si x est déclaré entière ou réelle, nom comme une chaîne de caractères et reponse

comme booléenne.

Remarques

(1) Le signe d'affectation est bien ":=" et non "=". Lorsque l'ordinateur rencontre un

tel signe, il évalue le membre de droite et place le résultat dans la variable dont

l'identificateur est le membre de gauche. En algorithmique cette opération est

représentée par le signe "<--".

(2) S'il s'agit d'une valeur numérique, la valeur inscrite à droite du signe d'affectation

peut être un calcul à effectuer (voir paragraphe suivant). S'il s'agit d'une valeur de

type alphanumérique, la valeur donnée explicitement doit être inscrite entre

apostrophes (En BASIC, il fallait des guillemets), sinon, la valeur peut aussi être

le résultat d'une opération (voir paragraphe sur les opérateurs alphanumériques).

(3) Cette même valeur peut également être introduite en utilisant la notation

scientifique (Ex: 1.435E03 pour 1.435 * 103 càd 1435).

b) Opérations sur les variables

Une fois que les variables ont une valeur, il est possible d’effectuer plusieurs opérations

différentes (phase de traitement). Ces opérations dépendent évidemment du type des

variables.


1) Opérateurs numériques

Le Turbo Pascal est muni d'une série d'opérateurs qui peuvent agir sur les différentes

variables numériques.

(1) Opérateurs agissant sur des réels et rendant un résultat réel.

On dispose, en plus des quatre opérations fondamentales (+, -, *, /), des fonctions

suivantes (l'argument est à placer entre les () ) :

• abs() : valeur absolue;

• sqrt() : racine carrée;

• cos() : cosinus;

• ln() : logarithme népérien;

• exp() : exponentielle de base e

• sqr() : carré;

• sin() : sinus ;

• arctan() : arctangente;

(2) Opérateurs agissant sur des réels et rendant un résultat entier.

• trunc() : partie entière;

• round() : valeur arrondie.

(3) Opérateurs agissant sur des entiers et rendant un résultat entier

En plus des opérations d'addition, de soustraction et de multiplication, on dispose

des fonction suivantes :

• x div y : quotient entier par défaut de x par y;

• x mod y : reste de la division entière de x par y;

• succ () : entier suivant;

• pred () : entier précédent.

2) Opérateurs alphanumériques

On peut introduire une valeur dans une variable caractère de trois façons différentes :

- soit on donne la valeur explicite entre apostrophes (a:='A';);

- soit on donne la valeur obtenue par application d'un des opérateurs

alphanumériques ci-dessous.

Dans ce paragraphe, <nombre> représente soit un nombre entier, soit une variable

entière; <caractère> est soit un caractère, soit une variable de type CHAR.

Les principaux opérateurs utilisant ou agissant sur des variables alphanumériques sont :

(1) chr (<nombre>) : qui donne le caractère dont le code ASCII est <nombre>.


Exemple var a : char;

a := chr(66);

donne à la variable a la valeur 'B'.

(2) ord(<caractère>) : qui donne le code ASCII de <caractère>.

Exemple var n : integer;

n := ord ('E');

donne à la variable n la valeur 69.

(3) upcase (<caractère>) : qui transforme toute lettre minuscule en majuscule.

Attention, cette fonction n'agit pas sur les caractères accentués, les chiffres, les

signes de ponctuation,...

Exemple var a,b: char;

a := 'e' ; b:=upcase(a);

donne à la variable b la valeur 'E'.

(4) succ(<caractère>) et pred (<caractère>) renvoient le caractère qui suit ou

précède <caractère> dans le code ASCII.

c) Affichage

En Pascal comme dans tous les autres langages, il est indispensable de demander à

l'ordinateur de communiquer ses résultats. L'instruction d'affichage à l'écran est

write(<liste d'identificateurs>);

où <liste> est l'ensemble des variables dont on souhaite afficher la valeur, séparées par des

virgules. Par exemple, write(x,y) affiche les valeurs de x et y côte à côte;

ou bien

write ('texte');

où texte est la suite de caractères que l'on souhaite voir affichée telle quelle. Par exemple,

write('Texte') affiche le mot "Texte" tel qu'il apparaît entre les apostrophes. Si le texte

contient des apostrophes, il convient de les doubler.


On peut représenter la syntaxe de cette instruction par le graphique ci-dessous.

write(

identificateur

' 'texte

);

,

Remarques

(1) Les valeurs des variables réelles sont par défaut affichées en utilisant la notation

scientifique. Pour éviter cet inconvénient, il suffit d'utiliser l'option suivante de

l'ordre write : write (x:n:p) permet d'afficher la valeur de x en utilisant n

caractères dont p sont réservés aux décimales (il reste donc n-p-1 caractères pour

la partie entière de x, il faut en effet 1 caractère pour le point). Un format trop

grand laisse des "blancs" devant le nombre, un format trop petit entraîne

l'impression de "*". Pour obtenir un nombre arrondi, donner la valeur 0 à p.

(2) Une autre variante de l'ordre write permet un retour à la ligne : l'instruction

writeln(...); effectue un saut à la ligne après l'impression demandée. L'ordre

writeln; envoie le curseur à la ligne.

(3) L'impression d'une variable à laquelle aucune valeur n'a été affectée (variable

non-initialisée) donne lieu à des résultats variables. En général, Pascal affiche une

valeur quelconque de son choix.

d) Lecture au clavier de plusieurs caractères

Le compilateur a l'avantage d'être plus rapide qu'un interpréteur lors de multiples exécutions

d'un même programme. Cependant, lorsqu'on veut faire tourner un programme avec

différentes valeurs pour les données, il faut, pour le moment, changer la déclaration de

constantes ou les différentes assignations. Il s'ensuit une modification du programme, et donc

une nouvelle compilation est nécessaire.

Le principe est simple, il suffit de donner à l'ordinateur l'ordre de demander la valeur à

l'utilisateur, l'ordinateur "lisant" la valeur au clavier. En Basic, cette opération est réalisée par

l'instruction archi-connue : INPUT.

En Pascal, cette opération se fait à l'aide de l'instruction

read(<liste d'identificateurs>);

où <liste> est l'ensemble des noms des variables, séparées par des virgules. Quand

l'ordinateur exécute cet ordre, il interrompt l'exécution du programme jusqu'à ce qu'une


valeur soit introduite au clavier et suivie d'un <RETURN>. La valeur introduite apparaît en

écho à l'écran.

Il faut évidemment que la valeur introduite corresponde au type de la variable, faute de quoi,

l'ordinateur signalera une erreur d'exécution (Run-Time error).

Syntaxe

On peut représenter la syntaxe de cet ordre par le graphique ci-dessous.

read( identificateur );

, Remarques

(1) En Basic, il est possible de faire afficher un petit texte expliquant ce que

l'ordinateur attend (INPUT"X=";X). En Pascal, il est indispensable d'utiliser un

ordre d'écriture juste avant l'ordre de lecture pour avoir le même effet. Par

exemple, les instructions write('X='); read(x); permettent à l'utilisateur de

mieux comprendre ce que l'ordinateur attend de lui.

(2) Une variante de l'ordre read permet un retour à la ligne après la lecture d'une

donnée au clavier. Ainsi les ordres d'impression suivants n'apparaissent plus sur

la même ligne à l'écran. Cette variante est

readln(<liste d'indentificateurs>);

où <liste> est l'ensemble des noms des variables, séparées par des virgules.

NDLR : On obtient quand même parfois des résultats bizarres lors de

l’introduction des valeurs de plusieurs .variables alphanumériques successives.

e) Lecture d'un caractère

Une dernière possibilité d'introduction de valeurs par l'intermédiaire du clavier est donnée par

la fonction readkey. Cette fonction permet à l'ordinateur de lire une touche au clavier. Elle

est prédéfinie dans l'annexe "crt"; de Pascal. Elle convient donc pour l'introduction d'une

lettre ou d'un chiffre -pas pour un mot ou un nombre-. La syntaxe à utiliser est

uses crt;

juste derrière la ligne d'en-tête et x:=readkey;

dans le corps du programme.

La valeur introduite au clavier n'est pas affichée en écho à l'écran. Il n'y a pas besoin

d'appuyer sur <RETURN> pour confirmer.


f) La fonction RANDOM

La fonction RANDOM est une fonction souvent utilisée en informatique. Au même titre que les

fonctions racine carrée -SQRT()-, valeur absolue -ABS()-, ou autres, la fonction RANDOM()

s'applique à un argument (variable ou nombre). Ainsi, on lira dans un programme RANDOM (X) ou RANDOM(1)

mais jamais RANDOM seul.

Lorsque la fonction RANDOM est utilisée avec un argument égal à 1, elle fournit un nombre

réel, aléatoire compris entre 0 et 1 (1exclus). Par exemple, x:=random(1);

Si la fonction RANDOM est utilisée avec un argument entier supérieur à 1 (n), elle fournit un

nombre entier pouvant prendre une des n valeurs différentes comprises entre 0 et n-1.

Exemples

x:=random(25); donne à x une des 25 valeurs de l'ensemble 0, 1, ..., 24.

x:=random(6)+1;donne à x la valeur d’un nombre entier entre 1 et 6.

Remarques

(1) Les nombres obtenus ne sont pas réellement aléatoires (càd ne dépendent pas

uniquement du hasard), ils sont obtenus suivant une logique propre à l'ordinateur,

très souvent basée sur l'horloge interne. Cependant, ces nombres ont les mêmes

propriétés que des nombres réellement aléatoires (jet de dé). On appelle donc les

nombres obtenus par l'ordinateur des nombres pseudo-aléatoires.

(2) L'utilisation correcte de la fonction RANDOM exige la présence obligatoire de

l'instruction RANDOMIZE. Sans cette instruction -qui doit figurer une fois avant

la première exécution de RANDOM-, l'ordinateur fournit une valeur aléatoire

puis conserve toujours cette valeur lors des utilisations suivantes de RANDOM.

(3) Pour "tirer une lettre au sort", il suffit un numéro puis de convertir ce nombre en

caractère grâce au code ASCII.

g) Instruction simple et macro-instruction

La notion d'instruction doit être précisée. Les premières instructions que l'on rencontre

généralement sont des instructions dites "simples" : affectation, impression, lecture au

clavier...

PASCAL permet la création de macro-instructions ou bloc d'instructions. Ce sont des

ensembles d'instructions simples commençant par begin et finissant par end. Partant de cette

définition, le corps d'un programme peut être considéré comme une macro-instruction.


On peut représenter la structure d'un macro-instruction par le graphique suivant :

end;begin instructions

Si plusieurs macro-instructions se succèdent, elles doivent être séparées par un ";", comme

s'il s'agissait d'instructions simples.

II.5. EXERCICES

1) Construisez un programme qui calcule et imprime :

(1) le périmètre d'un carré de coté 5,

(2) le périmètre d'un rectangle de longueur 7 et de largeur 5,

(3) la surface d'un carré de coté 5,

(4) la surface d'un rectangle de longueur 7 et largeur 5,

(5) la longueur d'un cercle de rayon 5,

(6) la surface d'un cercle de rayon 5,

(7) la longueur d'un cercle de diamètre 12,

(8) la surface d'un cercle de diamètre 12,

(9) le périmètre d'un polygone régulier ayant 12 côtés de longueur 8,

(10) la surface et le volume d'une sphère de rayon 5 (S = 4 π R2 et V = (4/3) π R3),

(11) la surface de base, la surface latérale, la surface totale et le volume d'un cylindre

droit à base circulaire de rayon 3 et de hauteur 7 (SB = π *R2; SL = 2 * π * R *

H; ST = SL + 2 * SB; V = SB *H),

(12) les trois surfaces latérales et la surface totale d'un parallélépipède rectangle dont

les côtés ont des longueurs respectives 4,6 et 7.

Remarque : Essayez d'imprimer aussi les unités des grandeurs ainsi évaluées, sachant que les

longueurs données s'expriment en cm.

2) Construisez un programme qui calcule et imprime :

(1) la surface, la longueur et le rayon d'un cercle de diamètre 12,

(2) la surface, le périmètre et la longueur de la diagonale d'un carré de côté 12,

(3) la surface, le périmètre et la longueur de la diagonale d'un rectangle de longueur 8

et de largeur 5,

(4) le diamètre, le rayon et la longueur d'un cercle de surface 12.

3) Construire un programme qui calcule le périmètre et la surface d'un triangle dont les

côtés sont donnés. (Si p est le demi-périmètre, S = ( )( )( )p p a p b p c− − − ).


4) Construisez un programme qui calcule :

(1) les intérêts rapportés sur un an par le placement d'un capital de 12000 F à un taux

de 6%. Calculez également le capital disponible à la fin du placement.

(2) les intérêts (simples) rapportés sur dix ans par le placement d'un capital de 12000

F à un taux de 6%. Calculez également le capital disponible à la fin du placement.

(3) les intérêts (composés) rapportés sur dix ans par le placement d'un capital de

12000 F à un taux de 6%. Calculez également le capital disponible à la fin du

placement.

(Suggestion : Cfinal = Cinitial * (1+taux)durée; intérêts = Cfinal - Cinitial , le taux est exprimé

en %).

5) Construisez un programme qui calcule l'intérêt simple de 50000 F placés au taux annuel

de 8% pendant 64 jours (intérêt = (capital * nb_de_jours * taux) / 360).

6) Construisez un programme qui connaissant le prix d'un article hors TVA et le taux de

TVA qui s'y applique, donne le prix TVA comprise.

7) Construisez un programme qui connaissant le prix de vente d'un article et la réduction

promise donne le prix réel.

8) Construisez un programme qui connaissant le prix unitaire d'un marchandise et la

quantité achetée donne le prix à payer.

9) Construisez un programme qui détermine le montant de la facture d'un client à partir du

prix unitaire hors TVA, du taux de TVA, de la réduction et de la quantité d'articles

achetés.

10) Construire un programme

(1) permettant la conversion une mesure d'angle de degrés, minutes, secondes en

degrés décimaux,

(2) permettant la conversion inverse.

11) Construire un programme

(1) qui convertit les degrés centigrades en degrés Farenheid. ( 9 325f cT T= + ),

(2) qui convertit les degrés Farenheid en degrés Celsius.

12) Construire un programme qui transforme

(1) un nombre d'heures en nombre de jours et heures.

(2) un nombre de jours donnés en nombre de jours, mois, années (1 mois = 30 jours,

1 année = 12 mois).


(3) un nombre de secondes en heures, minutes, secondes.

(4) un temps exprimé en heures, minutes et secondes en secondes.

(5) une durée exprimée en années, mois, jours en une durée exprimée en jours.

13) Construire un programme qui calcule le périmètre d'un polygone régulier de N côtés

circonscrit à un cercle de rayon R (P = 2 * N * R * tg(π/N)) et l'aire de ce polygone (A =

N * R2* tg( /N)).

14) Construire un programme qui convertit

(1) les angles exprimés en degrés en radians.(k degrés = k * 2 * π/360radians)

(2) Même programme, mais il doit être capable de transformer en radians des

amplitudes exprimées en degrés, minutes et secondes.

15) Construire un programme qui compte le nombre de billets de 5000, 1000, 500, 100 ou

de pièces de 50, 20, 5, 1 qu'il faut pour faire une somme aléatoire comprise entre 1 et

10000 F.


CHAPITRE III - L'ALTERNATIVE

III.1. INTRODUCTION

Lors de la construction de certains programmes, nous avons été confrontés à des problèmes

insolubles jusqu'ici. Par exemple, nous n'avons pas pu résoudre l'équation a x + b = 0 dans le

cas général; il faudrait utiliser des conditions (a…0, a=0, b=0...).

Il en est de même pour la résolution de l'équation du second degré ax2+b=0 qui n'admet de

solution(s) que si a et b sont de signes opposés.

Pour ces raisons, il est utile d'apprendre à évaluer des comparaisons ou tests (expressions

booléennes) et à le faire réagir de manière appropriée selon les résultats. On utilise pour cela

la structure appelée "alternative".

III.2. EXPRESSION BOOLÉENNE

On appelle expression booléenne toute expression qui peut prendre pour valeur vrai ou faux.

On distingue généralement deux types d'expressions booléennes : les comparaisons et les

variables booléennes.

a) Comparaison ou test

Les comparaisons ou tests sont (généralement) effectués à l'aide des différents opérateurs

relationnels <, >, (>=), (<=), <>, = (dont les significations sont claires), mais aussi de "in"

qui permet de vérifier si une valeur est contenue dans un ensemble (ce sujet est approfondi

plus loin). Ces opérateurs ne peuvent unir que des variables ou des expressions de même

type. Une comparaison prend donc une valeur parmi vrai ou faux (TRUE ou FALSE).

Exemple var x,y : integer;

x:=5; y:=3;

write(x<y);

write(x+1<>2*y);

fait afficher "false" puis "true". On peut représenter la structure d'un test par le schéma

suivant : variable

= <= < > >= <> in

variable


Chaque fois, on peut remplacer "variable" par une valeur de même type, une expression

faisant intervenir plusieurs grandeurs de même type, etc... Par exemple, 2*x mod y >

int(x+y) est valide.

b) Variables booléennes

Les variables booléennes sont des variables pouvant prendre les valeurs TRUE et FALSE.

On peut donc leur donner pour valeur une comparaison. Par exemple, var a : boolean;

a:=3<5; write(a);

fait afficher TRUE. Le type boolean est un type prédéfini (voir chapitre III, §2).

c) Opérateurs logiques

On appelle opérateurs logiques les mots NOT, AND, OR et XOR qui agissent sur des expressions

booléennes. Ils permettent respectivement de nier une expression booléenne, de soumettre

l'exécution d'une action à la réalisation simultanée de plusieurs expressions booléennes, soit

de soumettre cette exécution à la réalisation d'une expression parmi un ensemble.

1) NOT

La négation d'une expression se fait à l'aide du mot NOT. (On écrit IF NOT A ou IF NOT

(x<y) càd IF x>=y).

2) AND

La structure de l'algorithme est donc du type

SI <expression 1> ET <expression 2> ALORS <action>.

La conjonction ET est traduite par le mot AND. Dans cet exemple, <action> n'est

exécutée que si les 2 conditions reliées par AND sont vérifiées ensemble. Il suffit qu'une

seule des deux conditions ne soit pas vérifiée pour que l'action ne soit pas exécutée

(c'est l'action comprise derrière le ELSE éventuel qui est alors exécutée, sinon, c'est

l'instruction qui suit l'alternative).

3) OR


SI <condition 1> OU <condition 2> ALORS <action>.

La conjonction OU est traduite par le mot OR. Dans cet exemple, <action> n'est

exécutée dès qu'une des deux conditions reliées par OR l'est. Il faut que les deux

conditions ne soient pas vérifiées pour que l'action ne soit pas exécutée. Si les deux

conditions sont vraies, alors l'action est évidemment effectuée.


4) XOR


SI <condition 1> OU BIEN <condition 2> ALORS <action>.

La conjonction OU BIEN est traduite par le mot XOR (ou exclusif). Dans cet exemple,

<action> n'est exécutée dès qu'une des deux conditions reliées par XOR l'est. Il faut

qu'une seule des deux conditions soient vérifiées pour que l'action soit exécutée. Si les

deux conditions sont réalisées, ou si aucune des deux conditions ne l'est, alors l'action

n'est évidemment pas effectuée.

5) Ordre de priorité

En l'absence de parenthèses, la hiérarchie des opérateurs est la suivante :

• NOT, ± (changement de signe)

• *, /, DIV, MOD, AND (multiplication)

• +, -, OR, XOR (addition)

• =, <, >, <>, <=, >=, IN (comparaison)

Ce qui veut dire que var x,y,z : integer; a,b : boolean;

x:=3; y:=5; z:=8;

a:=not (x<y) or (z<y);

b:=not( (x<y) or (z<y));

donnent à a et b les valeurs respectives FALSE et TRUE.

III.3. CONDITION

Pour soumettre une instruction (ou une macro-instruction) à la réalisation d'une condition,

nous avons besoin d'une structure du type

SI <expression> ALORS <action>.

En PASCAL, elle se traduit par l'instruction :

IF <expression> THEN <action>

où <expression> est une expression booléenne au sens vu plus haut et <action> est une

instruction simple ou une macro-instruction.

Ainsi, si <expression> a pour valeur TRUE, l'ordinateur effectue <action>; sinon, il exécute

l'instruction suivante.


III.4. SI ... ALORS ... SINON ...

On peut améliorer la structure de la condition : elle peut contenir une action à réaliser si la

condition est fausse :

SI <expression> ALORS <action 1> SINON <action 2>

où <expression> est une expression booléenne au sens vu plus haut et <action 1> et

<action 2> sont des instructions simples ou des macro-instructions. On parle alors

d'alternative.

L'ensemble est traduit par

IF <expression> THEN <action 1> ELSE <action 2>

Ainsi, si <expression> est vraie, alors l'ordinateur effectue <action 1>, sinon il exécute

<action 2>; et ensuite l'instruction de la ligne suivante.

Syntaxe

La syntaxe de l'alternative est illustrée par le graphique suivant :

if expression then instructions else instructions

Remarque

Jamais de ";" devant le mot ELSE. L'instruction IF ...THEN ... ELSE forme un seul

bloc. En insérant un ";" avant le ELSE, on "coupe" l'instruction en deux, la seconde

"instruction" commençant par "ELSE" : impossible.

III.5. CHOIX MULTIPLE

Dans beaucoup de situations, l'alternative, même complète, ne suffit pas parce que l'ensemble

des cas possibles comprend plus que deux éléments. L'instruction "au cas où" permet de faire

réagir l'ordinateur de plusieurs manières différentes selon la valeur d'une même variable

(exemple : menus).

La structure de cette instruction est

AU CAS OÙ <variable> of case car of

valeur_1 : <action_1>; '+' : x:=y+z;

... ...

valeur_n : <action_n> '/',':' : x:=y/z;

AUTREMENT <action> else writeln('pas possible');

end; end;


où <variable> représente généralement l'identificateur d'une variable, ou une expression

pouvant prendre pour un nombre fini de valeurs (integer, char, boolean,...), où <valeur_i>

représentent différentes valeurs possibles de <variable> et où <action_i> sont des instructions

simples ou des macro-instructions à exécuter.

Si plusieurs valeurs doivent donner lieu à l'exécution de la même instruction, ces différents

valeurs peuvent êtres regroupées dans <valeur_i>. Il suffit de les séparer par des virgules.

La partie "AUTREMENT" permet de faire exécuter un intruction commune pour toutes les

valeurs acceptables pour la variable qui n'ont pas été reprises dans l'énumération qui précède.

Elle est facultative, et même inutile si toutes les valeurs possibles ont été reprises dans

l'énumération.

Syntaxe

La syntaxe de cette instruction peut être illustrée par le schéma suivant :

case identificateur of valeur : instruction

else instruction

end;

,

III.6. CRITÈRES DE DIVISIBILITÉ

Construisons un algorithme et un programme permettant de dire si un nombre est pair ou

impair. Il suffit d'exprimer qu'il est divisible par 2. On dispose de trois possibilités :

• soit on exprime que le quotient de la division est entier : N/2 = trunc(N/2);

• soit on exprime que la division entière donne le même résultat que la division

réelle : (N div 2) = N/2;

• soit on exprime que le reste de la division entière est nul : N mod 2 = 0.

L'instruction SI N pair ALORS afficher "N pair" SINON afficher "N impair" devient

respectivement

• IF (N/2)=INT(N/2) THEN WRITE (N,'PAIR') ELSE WRITE (N,'IMPAIR')

• IF (N div 2) = N/2 THEN WRITE (N;'PAIR') ELSE WRITE (N,'IMPAIR')

• IF N mod 2 = 0 THEN WRITE (N;'PAIR') ELSE WRITE (N,'IMPAIR')

Remarque

Les deux dernières méthodes ont l'inconvénient de ne s'appliquer qu'à des nombres de

type entier (car font appel aux opérateurs div ou mod). Par conséquent, il ne

conviennent que pour des nombres déclarés comme integer, longint, shortint,

byte ou word.


III.7. EXERCICES

1) Tirer un nombre aléatoire entre 0 (inclus) et 2 (exclus). Indiquer s'il est plus grand ou

plus petit que 3.

2) Simuler un jeu de "pile" ou "face". Suggestion : tirer un nombre aléatoire qui vaut soit

0, soit 1; 0 correspond à "pile" et 1 à "face".

3) Tirer un nombre aléatoire entier compris entre 1 et 1000. Indiquer s'il est pair ou

impair.

4) Entrer deux nombres entiers X et Y. Comparer les 2 nombres (>, <, =) et indiquer si X

divise Y ou si Y divise X.

5) Construire un programme qui indique si un nombre entier aléatoire est un multiple de 2,

de 3, de 5 ou de 7.

6) Tirer 3 nombres entiers aléatoires entre 1 et 10.

(1) Indiquer si deux d'entre eux sont égaux.

(2) Indiquer s'ils peuvent constituer les côtés d'un triangle. Suggestion : dans un

triangle, chaque côté est inférieur à la somme des deux autres.

(3) Grouper les deux programmes ci-dessus de façon à ce que l'ordinateur indique si

les trois nombres tirés au sort peuvent être les côtés d'un triangle isocèle.

(4) Indiquer s'ils sont les longueurs des côtés d'un triangle équilatéral.

7) Tirer 3 entiers au sort : le premier compris entre 5 et 15, les deux autres entre 1 et 8.

Vérifiez s'ils peuvent constituer les côtés d'un triangle rectangle dont l'hypoténuse est le

premier nombre. (Le carré de l'hypoténuse est égal à la somme des carrés des deux

autres côtés).

8) Deux personnes jouent avec un dé à 6 faces. Chacune d'elles donne un nombre entre 1

et 6, puis on lance le dé. La personne qui a trouvé le bon nombre a gagné. Si personne

n'a trouvé, les deux joueurs ont perdu.

(1) Construire un programme qui permet de simuler ce jeu.

(2) Modifier le jeu précédent de façon à ce que ce soit le joueur dont le nombre est le

plus proche du nombre obtenu par le dé qui gagne. Si les deux joueurs sont à

même distance, ils font "match nul".


9) Deux joueurs choisissent une lettre de l'alphabet et l'ordinateur tire une lettre au sort

(ATTENTION : ce programme nécessite la connaissance du code ASCII des lettres).

Le joueur qui gagne est celui qui a trouvé la lettre la plus proche.

(1) Ecrire un programme qui simule ce jeu.

(2) Améliorer ce programme pour que le joueur qui gagne soit le plus proche de la

lettre quel que soit le sens de comptage ( Z est plus proche de A que G).

10) Construire un programme qui indique si une année est bissextile sachant qu'une année

est bissextile si elle est divisible par 4 et pas par 100 ou bien divisible par 400.

11) Construire un programme qui

(1) permet d'additionner deux durées exprimées en heures minutes (sans les convertir

en minutes). Par exemple, 6h 45m + 5h 24 m = 12h 9m.

(2) Améliorer le programme précédent pour que l'on obtienne le nombre de jours

écoulés si le nombre d'heures dépasse 24. Par exemple, 18h 56m + 8h 45m = 1j

3h 41m.

(3) Construire un programme qui permet de soustraire deux durées exprimées en

heures, minutes, secondes (ex : bonifications dans une course cycliste).

12) Construire un programme qui permet d'additionner deux amplitudes d'angles exprimées

en degrés, minutes, secondes.

13) Construire un programme qui résout l'équation du premier degré à une inconnue a x +

b = 0 dans tous les cas.

14) Construire un programme qui résout complètement l'équation du second degré a x2 + b

x + c = 0 par la méthode du réalisant.

Algorithme : On calcule ∆ =b2 - 4 a c.

Si ∆ >0, alors l'équation admet deux solutions distinctes : 1

2

2

2

bxa

bxa

− + ∆=

− − ∆ =

Si ∆ =0, alors l'équation admet une racine double x = 2

ba

− .

Si ∆ <0, l'équation n'admet pas de solution.

15) Construire un programme qui résout complètement un système de deux équations du

premier degré à deux inconnues : 1 1 1

2 2 2

a x b y ca x b y c

+ = + =

par la méthode de CRAMER.


Algorithme : On calcule le déterminant des coefficients des inconnues 1 1

2 2

a bD

a b= .

Si D … 0, alors le système admet une solution unique

1 1 1 1

2 2 2 2,

c b a cc b a c

D D

où les

numérateurs, respectivement appelés Nx et Ny, sont calculés de la même façon que D

(différence des produits croisés).

Par contre, si D=0, alors le système est soit indéterminé - si un des deux numérateurs

est nul (le second l'étant automatiquement aussi)- soit impossible - si un des deux

numérateurs est différent de zéro (le deuxième numérateur étant automatiquement non

nul également.

16) Construire un programme qui demande le prix d'un article H.T.V.A., puis demande si le

client est assujetti à le T.V.A.. Si oui, le programme demande le taux de T.V.A.

s'appliquant à l'article et calcule et imprime le prix à payer (T.V.A.C.).


CHAPITRE IV - STRUCTURES RÉPÉTITIVES

IV.1. INTRODUCTION

Un autre problème est de faire exécuter une (ou plusieurs) instruction(s) par l'ordinateur

plusieurs fois. Il est indispensable de comprendre qu'il ne suffit pas de dire quelque chose du

type "répéter <action>". En effet, cela entraînerait la répétition infinie de <action>. Il faut

donc prévoir un test d'arrêt. Ce test peut être effectué avant ou après l'exécution de <action>.

Par exemple, nous souhaitons afficher la surface de tous les carrés dont la longueur des côtés

sont les entiers compris entre 1 et 22. Trois cas sont envisageables : soit on souhaite que

l'ordinateur exécute le même ensemble d'instructions tant qu'une condition est vraie (afficher

le carré tant que la longueur du côté est inférieure ou égale à 22), soit jusqu'à ce qu'une

condition soit vraie (afficher le carré jusqu'à ce que la longueur du côté soit égale à 23), soit

qu'il exécute cet ensemble d'instructions un nombre précis de fois (pour des longueurs

comprises entre 1 et 22).

Dans le premier cas, nous parlerons de la structure "TANT QUE" (ou WHILE), dans le second

de la boucle "REPETER...JUSQU'A" (ou REPEAT...UNTIL), et dans le troisième de la boucle

"POUR" (ou FOR). Les deux premières boucles sont dites conditionnelles, la raison de l'arrêt

est explicitement une condition. La troisième est dite inconditionnelle car on peut déterminer

à l'avance le nombre de répétitions, la raison de l'arrêt est une condition implicite.

On peut aussi imaginer que l'ordinateur effectue certaines tâches tant que l'utilisateur ne

demande pas l'arrêt (en appuyant sur une touche par exemple). Dans ce cas, on utilise une des

structures "TANT QUE" ou "REPETER JUSQU'A". Ces deux structures sont très souvent

utilisées dans ce rôle.

Il est intéressant de savoir que tout ce qui peut être réalisé avec la boucle "POUR" peut être

facilement réalisé à l'aide de "TANT QUE" ou de "REPETER...JUSQU'A". L'inverse est

moins évident, voire impossible. Pour cette raison, nous verrons tout d'abord la première

solution.


IV.2. TANT QUE

a) Exemple

Essayons d'afficher les nombres naturels de 1 à 10. La seule solution que nous puissions

apporter à l'aide de nos connaissances actuelles est de donner une suite d'ordres du type i:=1 ; write(i);

i:=2 ; write(i);

...

i:=10; write(i);

Quelle lourdeur ! La formulation suivante est plus appropriée :

ALGORITHME PROGRAMME

i = 1

tant que i<=10

afficher i

i < i+1

fin de tant que

PROGRAM affiche;

VAR i : integer;

BEGIN

i := 1;

WHILE i <= 10 DO

BEGIN

WRITE(i);

i := i + 1;

END;

END.

b) Structure

La structure de "TANT QUE" est toujours du type

TANT QUE <expression> FAIRE <action>

ce qui se traduit en Pascal par

WHILE <expression> DO <action>

où <action> représente une instruction ou une macro-instruction (appelée corps de la boucle)

et <expression> est une expression booléenne. L'ordinateur évalue <expression> avant

chaque exécution de <action>, <action> n'étant réalisée que si <expression> est vraie. Dès

que <expression> est fausse, l'ordinateur passe à l'exécution de la première instruction qui

suit la boucle.

Lorsque l'ordinateur reçoit le programme ci-dessus, il agit de la manière suivante : il

enregistre la valeur de i et compare i à 10. Comme i est inférieur ou égal à 10, il exécute une

fois la macro-instruction (de BEGIN à END;), à ce moment, il "remonte" au WHILE et effectue à

nouveau le test... Le programme se termine par les actions suivantes : il affiche 10, ajoute 1 à


i et compare i (qui vaut 11) à 10. L'expression est fausse, l'ordinateur exécute l'instruction qui

suit le END; (dans ce cas, il arrête).

Syntaxe

On peut illustrer la structure de WHILE par le schéma suivant :

WHILE expression DO instructions

Remarques

(1) Si <expression> est faux dès le départ, <action> n'est jamais effectuée.

(2) La variable i joue le rôle d'indice de boucle ou de variable de contrôle. C'est sa

valeur qui détermine si l'expression booléenne suivant le WHILE est vérifiée. Il

ne faut donc pas oublier de la modifier (ici : augmentation de 1), sous peine de

voir le programme "boucler sans fin". (Exemple : le même programme sans la

ligne i:=i+1; affiche le chiffre 1 sans arrêt).

(3) L'opération i:=i+1 s'appelle l'incrémentation. On dit qu'on incrémente i de 1.

Suivant les applications souhaitées, on peut incrémenter de 2, de 0.5, de -1...

(4) Il ne faut pas oublier non plus d'initialiser la variable de contrôle.

c) Deuxième exemple

Construisons un programme demandant un caractère au clavier jusqu'à ce qu'il reçoive un des

quatre signes d'opérations : +, -, *, /.On a l'algorithme et le programme suivants :


lire car

TANT QUE car pas dans +,-,*,/

afficher texte

lire car

FIN TANT QUE

PROGRAM attend_caractere;

VAR car :char;

BEGIN

write('caractère');read(car);

WHILE not car in ['+','-

','*','/'] DO

BEGIN

write('caractère');

read(car);

END;

END.


Remarques:

(1) Il est important de faire lire la variable car avant de faire le test (sinon, celui-ci n'a

pas de sens). Puis dès qu'on sait que la condition est vraie (c'est-à-dire que le

caractère introduit n'est pas bon), redemander une valeur pour car.

(2) La grande différence entre cet exemple et le précédent est le suivant : dans le

premier cas, nous connaissions dès le départ le nombre d'exécutions du corps de

la boucle, dans le second, cela n'est pas aussi évident. Donc, s'il est très facile de

réaliser le premier exemple à l'aide de la boucle "POUR", le second s'avère

impossible en utilisant ce dernier type de boucle.

IV.3. RÉPÉTER...JUSQU'À

a) Exemple

Reprenons le premier exemple de la structure "TANT QUE".

ALGORITHME

introduire i=1

repeater

afficher i

augmenter i de 1

jusqu'à i>10

PROGRAM affiche;

VAR i : integer;

BEGIN

i := 1;

REPEAT

WRITE(i);

i := i + 1;

UNTIL i>10;

END.

b) Structure

La structure de "REPETER...JUSQU'A" est toujours du type

REPETER <action> JUSQU'A <expression>


REPEAT <action> UNTIL <expression>

où <action> représente une instruction ou une macro-instruction (corps de la boucle) et

<expression> est une expression booléenne.


Les instructions sont exécutées jusqu'à ce que <expression> devienne vrai, c'est-à-dire tant

que <expression> est faux. Dès que <expression> est vrai, l'ordinateur passe à l'exécution de

la première instruction qui ne doit pas être répétée.

Lorsque l'ordinateur reçoit le programme ci-dessus, il agit de la manière suivante : il

enregistre la valeur de i, exécute une fois la macro-instruction (entre REPEAT et UNTIL),

compare la valeur de i à 10. Comme i est inférieur à 10, il "remonte" au REPEAT et effectue à

nouveau la macro-instruction... Le programme se termine par les actions suivantes : il affiche

10, ajoute 1 à i et compare i (qui vaut 11) à 10. L'expression est vraie, l'ordinateur exécute

l'instruction qui suit le END; (dans ce cas, il arrête).

Syntaxe

On peut illustrer la structure de REPEAT par le schéma suivant :

REPEAT UNTILinstructions expression

Remarques

(1) L'ordinateur effectue toujours au moins une fois <action>, même si <expression>

est vraie dès le départ (ce n'est pas le cas avec WHILE). Cela est du au fait que le

test d'arrêt est effectué après l'exécution du corps de la boucle.

(2) L'ensemble des instructions à effectuer (macro-instruction) ne doit pas

nécessairement commencer par BEGIN et finir par END;. Et pour cause, le

REPEAT suffit à marquer le début du bloc et le UNTIL la fin.


Essayons d'afficher tous les nombres naturels dont le carré est inférieur à 85. Grâce à la

structure "REPETER...JUSQU'A", nous avons l'algorithme et le programme suivants :

Construisons un programme demandant un caractère au clavier jusqu'à ce qu'il reçoive un des

quatre signes d'opérations : +, -, *, /. On a l'algorithme et le programme suivants :


REPETER

afficher texte

lire car

JUSQU'A CE QUE car dans '+','-''*','/'

PROGRAM attend_caractere;

VAR car :char;

BEGIN

REPEAT

write('caractère');

read(car);

UNTIL car in ['+','-','*',/'];

END.


Remarque

(1) La grande différence entre cet exemple et le précédent est le suivant :

contrairement au premier cas (WHILE), la macro-instruction est toujours exécutée

au moins une fois.

IV.4. POUR

a) Exemple

La troisième solution pour faire exécuter plusieurs fois un ensemble d'instructions est de

demander un nombre précis d'exécutions. On utilise alors un compteur, généralement de type

entier, auquel on donne une valeur de départ et une valeur d'arrivée. En utilisant cette

méthode, on peut apporter la solution suivante au problème de l'exemple 1 ci-dessus.


POUR i=1 à 10

DO

afficher i

FIN POUR

PROGRAM affiche;

VAR i : integer;

BEGIN

FOR i:=1 TO 10 DO

WRITE(i);

END.

b) Structure

La structure de "POUR" est toujours du type

POUR compteur = <valeur_départ> TO <valeur_fin> DO <action>


FOR <compteur>:= <valeur_départ> TO <valeur_arrivée> DO <action>

où <action> est une instruction simple ou une macro-instruction aussi appelée corps de la

boucle.

Lorsque l'ordinateur exécute le programme ci-dessus, il agit de la manière suivante : il affecte

la valeur <valeur_départ> à <compteur> et compare cette valeur à <valeur_fin>. Si i est

inférieur ou égal à <valeur_fin>, il exécute une fois <action>, puis il incrémente <compteur>

de 1 (il passe à la valeur suivante), remonte au FOR..TO...DO, et compare à nouveau

<compteur> à <valeur_fin>. Le programme se termine lorsque i vaut 11 : il affiche 10, ajoute

1 et compare <compteur> (qui vaut 11) à 10. I n'est plus inférieur ou égal à <valeur_fin>,

l'ordinateur exécute l'instruction qui suit le corps de la boucle.


Remarques

(1) Si <valeur_départ> est supérieur à <valeur_fin>, <action> n'est jamais effectuée.

En effet, la comparaison entre <compteur> et <valeur_fin> se fait avant chaque

exécution de <action>.

(2) <action> peut être composé d'un seule instruction si on le souhaite (comme dans

l'exemple ci-dessus). Si <action> est un bloc d'instructions (voir exemple

d'addition de nombres dans une boucle), alors il faut impérativement "begin" et

"end;" à ses extrémités, faute de quoi, seule la première instruction du bloc est

répétée.

(3) Contrairement aux structures "TANT QUE" et "REPETER...JUSQU'A", il n'est

pas nécessaire d'initialiser le compteur avant le début de la boucle.

(4) L'incrémentation se fait automatiquement. Une instruction du type i:=i+1

fausserait le bon déroulement de l'exécution ou provoquerait une erreur de

compilation.

(5) Il faut évidemment avoir <valeur_départ> > <valeur_fin> pour un usage normal.

(6) Il n'est pas possible de changer la valeur d'incrémentation (comme en BASIC) par

un ordre STEP. Par contre, il est possible de "décrémenter" grâce à

(7) FOR <compteur>:= <valeur_départ> DOWNTO <valeur_fin> DO <action>

Syntaxe

On peut illustrer la structure de FOR...TO par le schéma suivant :

FOR variable := val initiale to valeur finale do instructions


On sait déjà que l'exemple développé en deuxième place dans les structures précédentes est

impossible à réaliser dans le cas présent.

Prenons donc pour exemple, un programme qui affiche tous les nombres naturels dont le

carré est inférieur à 85. La boucle "POUR" convient mal à ce genre d'exercice car il faut

d'abord déterminer le nombre de fois que la macro-instruction sera exécutée. Ce qui se révèle

assez peu pratique. En effet, dans ce cas précis, il faudrait faire exécuter la boucle pour i

allant de 1 à trunc(sqrt(85)) !


IV.5. ADDITION DE N TERMES DANS UNE BOUCLE

Supposons avoir dix nombres à additionner. Sans utiliser les boucles, nous devons essayer

quelque chose du type a:=5; b:=3;...;j:=8;

total := a + b + ...+ j;

write(total);

(Ne pas laisser les "..." ainsi).

En espérant qu'il ne faudra jamais additionner 1000 nombres ! Il est important de constater

que cette façon de procéder consiste à traiter les nombres à additionner "en bloc" : on les

introduit tous ensemble puis on les additionne sur la même ligne.

Une autre méthode consiste à traiter les données une par une, cela peut se faire grâce aux

boucles : on utilise une variable "total" initialisée à 0 au départ, puis on lit un nombre, on

l'ajoute au total, puis on lit le nombre suivant, ... jusqu'au dernier (c'est la démarche qu'on

utilise avec une machine à calculer).


introduire nombre de termes (N)

termes');READ(n);

total < 0

POUR i = 1 à N

introduire un terme(X)

total < total+x

FIN POUR

afficher total

PROGRAM addition;

VAR i,n : integer;

x,total : real;

BEGIN

WRITE('nbre de total:=0;

FOR i:=1 TO n DO

BEGIN

WRITE('nombre');

READ(x);

total := total + x;

END;

WRITELN('TOTAL',total);

END.

Remarques

(1) L'initialisation du total à 0 est indispensable en PASCAL. On peut s'en passer en

BASIC, pas en PASCAL (Quand PASCAL rencontre une variable déclarée mais

non initialisée, il lui donne une valeur aléatoire -contenu d'une case mémoire

quelconque-, tandis que BASIC donne la valeur 0).


(2) La variable x prend successivement les valeurs qu'on lui donne. Il est faux de dire

que x prend toutes les valeurs en même temps. Chaque fois que l'ordinateur passe

par l'ordre READ(x); il remplace le contenu de la boîte "x" par la nouvelle valeur

introduite.

(3) Une égalité du type total :=total + x; n'a aucun sens en mathématique. cependant,

on peut l'utiliser en informatique. En effet, il faut se rappeler que lorsque

l'ordinateur rencontre une telle opération (affectation ou assignation), il réagit en

évaluant le membre de droite (il calcule donc total + x) et met la valeur obtenue

dans la variable de gauche (donc dans total). En bref, l'ordinateur remplace donc

l'ancienne valeur de total par une nouvelle obtenue par la somme de l'ancienne et

d'un terme.

IV.6. EXERCICES

a) Boucles

1) Construire un programme qui imprime

(1) les entiers de 1 à 10,

(2) les entiers de 10 à 1,

(3) les nombres pairs de 0 à 40,

(4) les nombres multiples de 0.5 de 10 à 1,

(5) la table de multiplication par 8 (ou ....),

(6) les entiers de 1 à 10 et leurs carrés,

(7) les entiers pairs compris entre 1 et 10, leurs carrés et leurs cubes,

(8) les nombres de 33 à 127 ainsi que les caractères de code ASCII correspondants,

(9) les entiers positifs dont la racine carrée est inférieure à N (N = nombre donné).

2) Construire un programme qui simule le lancer d'un dé.

(1) L'ordinateur joue sans arrêt jusqu'à ce qu'il tire un "6" (ou un autre nombre à

introduire par INPUT). Faire imprimer les résultats des tirages.

(2) L'ordinateur s'arrête lorsqu'il a tiré successivement un "2", puis un "4".

3) Construire un programme qui calcule le P.G.C.D. de deux nombres entiers positifs m et

n (m>n) selon l'algorithme d'Euclide : on calcule le reste de la division de m par n, puis

le reste de la division de n par ce premier reste,... jusqu'à ce que le reste soit nul. Le

dernier diviseur trouvé est le P.G.C.D.


4) Construire un programme qui calcule la racine carrée d'un nombre A positif en utilisant

l'algorithme suivant : on construit une suite de nombres dont le 1er terme est 01

2Ax += ,

les suivants sont obtenus par la relation 1 2

nn

n

Axxx +

+= .

(1) On s'arrête après 10 itérations;

(2) on s’arrête quand la différence entre 2 termes consécutifs est inférieure à 10-3.

5) Construire un programme qui calcule les 16 premiers termes de la suite de Fibonacci.

Le premier terme T1 est 1, le second T2 est 2, les suivants s'obtiennent en additionnant

les deux termes précédents (T3 = 3, T4 = 5,...). Calculer les 15 premiers termes de la

suite formée par les quotients de 2 termes consécutifs de la suite de Fibonacci (F1 = T1

/T2, F2 = T2 /T3,...).

6) Construire un programme qui réalise le jeu de la fourchette : l'ordinateur génère un

nombre entier au hasard entre 1 et 100; il demande une valeur au joueur, indique si

cette valeur est trop grande ou trop petite et affiche le nombre d'essais (nombre d'essais

max : 15).

7) Construire un programme qui calcule le capital (Cn) et les intérêts (i) composés obtenus

après le placement d'un capital (Co) à un taux exprimé (t) pendant une durée (n)

exprimée en années :

(1) le programme affiche le capital et les intérêts récoltés après chaque année,

(2) le programme affiche le capital et les intérêts obtenus après le placement d'un

capital de 1000 à 8000 F par tranche de 500 F,

(3) le programme affiche le capital et les intérêts obtenus après le placement d'un

capital à un taux variant de 5 à 10% par pas de 0.5%,

(4) le programme calcule le nombre d'années nécessaires pour que le capital final soit

supérieur ou égal au double du capital initial.

8) Construire un programme qui affiche les valeurs en francs belges de sommes allant de 1

à 10 dollars ( 1 $ = 30.66 FB).

9) Construire un programme qui établit une table de conversion

(1) des degrés centigrades (de 0 C à 100 C par pas de 5 C) en degrés Fahrenheit,

(2) des degrés Fahrenheit (de 0 F à 200 F par pas de 10 F) en degrés Celsius sachant

que Tf = Tc * (9/5) + 32 et Tc = (5/9)*(Tf - 32).


10) Construire un programme qui affiche une table des sinus et cosinus des angles de 0° à

90° par pas de 5°. Vérifier que sin 2 α + cos 2 α = 1, quelque soit . Attention, il faut

convertir les amplitudes en radians (k degrés = k * 2 * π / 360 radians).

11) Construire un programme simulant une horloge : on lui donne une heure de départ,

l'ordinateur ajoute 1 aux secondes, puis 1 aux minutes lorsqu'il y a 60 secondes,... Ce

n'est que dans un deuxième temps que l'on essayera de synchroniser l'horloge.

N.B. Prévoir un test d'arrêt.

b) Additions dans une boucle

1) Construire un programme qui additionne dix nombres entiers aléatoires compris entre 1

et 10 et en fait la moyenne.

2) Construire un programme qui simule un jeu de dés. Il joue sans arrêt jusqu'à ce qu'il tire

un six. Faire imprimer tous les résultats des tirages. Compter le nombre d'essais.

3) Construire un programme qui tire des lettres au sort (à l'aide du code ASCII) jusqu'à ce

qu'il tire un "Z". Faire imprimer tous les résultats des tirages. L'ordinateur imprime

alors le nombre d'essais tentés.

4) Construire un programme qui calcule la somme des N premiers entiers. (On peut

vérifier que ( 1)2n

n nS += .

5) Construire un programme qui calcule le pourcentage obtenu par un élève qui réalise 5

interrogations de 6/10, 5.5/10, 12/30, 9/15, 8.5/20. (Calculer le total des points, le total

des maxima puis le pourcentage).

6) Construire un programme qui calcule la factorielle d'un nombre entier N donné.

(Prononcer "factorielle N" ou "N factorielle"). La factorielle d'un nombre N est le

produit des N entiers positifs inférieurs ou égaux à N. On la note N! (3! = 3.2.1 = 6)

7) Construisez un programme qui calcule la résistance équivalente à une association de N

(N nombre donné) résistances en parallèle. (L'inverse de la résistance équivalente est

égale à la somme des inverses des résistances).

8) Adapter le programme précédent pour qu'il fonctionne si le nombre de résistances n'est

pas déterminé à l'avance. L'introduction des résistances est arrêtée par l'introduction de

la valeur 0.

9) Un client achète dans une grande surface. Pour chaque article, la caissière encode le

numéro de l'article, la quantité achetée et le prix unitaire. Calculer le nombre total


d'articles et le montant à payer. Le nombre d'articles différents est indéterminé, on

termine en encodant 0 pour le numéro.

10) Construire un programme qui calcule la moyenne (µ) et l'écart-type ( σ ) des 100

premiers entiers. (L'écart type d'un ensemble de nombres est la racine carrée du

quotient de la somme des carrés des différences entre les nombres et leur moyenne par

le nombre de nombres :

2 2 2(1 ) (2 ) (100 )100

µ µ µσ − + − + + −= �

.

11) Un véhicule démarre en M.R.U.A. d'accélération a = 2 m/s2. On demande de calculer

sa position tous les dixièmes de secondes jusqu'à ce qu'il atteigne la vitesse de 30 m/s.

Les lois sont respectivement v(t) = a * t et d(t) = a * t2 / 2 pour la vitesse et le

déplacement.

12) Un obus est lancé par un canon dans une direction faisant avec le sol horizontal un

angle α. Calculer le temps mis par l'obus pour retomber ainsi que la distance parcourue

horizontalement. Si t désigne le temps qui s'écoule depuis le lancement de l'obus et v0

le module de la vitesse de départ, alors le déplacement vertical de l'obus est donné par

la loi de mouvement des corps lancés vers le haut : y(t) = v0 t sin α - g t2/2 et le

déplacement horizontal par la loi du mouvement rectiligne uniforme : x(t) = v0 t cos α

On calcule y(t) pour des temps partant de 0.1 s. L'obus est retombé lorsque y(t) < 0.

13) Rendre les programmes des jeux déjà construits "monkey save". Faire recommencer

l'introduction des chiffres ou lettres des joueurs jusqu'à ce qu'ils correspondent aux

réalités : par exemple, ne pas pouvoir introduire un nombre négatif lorsqu'on joue au

dé, ne pas pouvoir introduire "%" si on demande une lettre,...On peut encore l'améliorer

en n'exigeant plus que les joueurs doivent confirmer en appuyant sur <RETURN> (en

utilisant la fonction INKEY$).

c) Boucles et conditions

1) Construire un programme qui simule une dizaine de jets de pièce (jeu de pile ou face).

Deux joueurs jouent à "pile ou face". Le jeu s'arrête lorsque un des deux joueurs a

gagné 5 fois.

2) Construire un programme qui détermine tous les diviseurs d'un nombre entier donné.


3) Construire un programme qui détermine tous les nombres parfaits : un nombre parfait

est un nombre égal à la somme de tous ses diviseurs autres que lui-même (ex: 6 car

1+2+3 = 6).

4) Réaliser le jeu suivant : l'ordinateur part d'un nombre entier aléatoire compris entre 50

et 150. Deux joueurs doivent soustraire à tour de rôle un nombre entier compris entre 1

et 9. Le joueur qui arrive à 0 a perdu.

5) Construire un programme qui permet de jouer au jeu "chercher une lettre" jusqu'à ce

qu'un des deux joueurs ait 5 points.

6) Idem, le jeu s'arrête lorsqu'un des deux joueurs a 6 points et deux points d'avance sur

l'autre (comme au tennis).


CHAPITRE V - FONCTIONS

V.1. INTRODUCTION

Les fonctions sont un outil de PASCAL : elles s'appliquent à une ou plusieurs variables

(arguments). donnent un résultat (numérique, alphanumérique, ...) suivant les cas.

Les exemples les plus connus de fonctions sont les fonctions mathématiques classiques :

sin(x), ln (x), sqrt(x),... sont des fonctions qui s'appliquent à une variable et qui

donnent un résultat. Ce sont des fonctions prédéfinies.

Si ces fonctions ne suffisent pas (par exemple, il n'y a pas de fonction "cube", de fonction

cotg(x), de fonction puissance nème de x, surface du rectangle, montant de la tva en fonction

du prix htva et du taux,...), Pascal offre la possibilité de les définir puis de les utiliser.

La phase de déclaration consiste à définir la fonction (lui donner un nom, déterminer le

nombre et le type de variables dont la fonction dépend et définir le mode de calcul du

résultat) se fait de façon analogue à la déclaration des procédures (avant le corps du

programme).

La deuxième phase est la phase d'utilisation lors de laquelle on demande à l'ordinateur de

calculer la valeur de la fonction à l'aide des valeurs qu'on lui donne pour les paramètres.

V.2. CONSTRUCTION

a) Structure

La structure d'une fonction est la même que celle d'un programme (ou d'une procédure).

Seule la ligne d'en-tête est légèrement modifiée.

On y trouve d'abord

- la ligne d'en-tête (obligatoire) commence par le mot function suivi

- du nom de la fonction,

- d'une liste d'arguments sur lesquels la fonction doit agir ( identificateur(s) et

type). Tous ces arguments sont transmis par valeur, la fonction n'a pas pour

but d'en modifier la valeur.

- du type de résultat fourni par la fonction.

- la partie déclarative contient les déclarations de constantes, de variables

(locales, facultatives),... et même d'autres procédures ou fonctions qui

pourraient intervenir dans le mode de calcul du résultat.


- - le corps de la fonction commence par begin, finit par end; dont le but est de

déterminer comment obtenir la valeur souhaitée. Il contient nécessairement

une affectation donnant la valeur de la fonction ( nom de la

fonction:=valeur).

Syntaxe

La syntaxe de la déclaration d’une fonction est représentée dans le schéma suivant :

Function identificateur ;(

identificateur : type de variable ;

,

)

: type du resultat

b) Exemples

1) Fonction cube program cubes;

var a : real;

function cube (x : real) : real;

begin

cube:=x*x*x;

end;

La fonction s'appelle "cube", s'applique à

un argument x réel et donne un résultat

réel

begin

write('Introduire un nombre');

readln (a);

write('a^3 = ’,cube(a));

end.

La variable x qui est utilisée pour définir la fonction ne joue pas un vrai rôle. elle est là

uniquement pour décrire la façon d'obtenir la valeur de la fonction. On dit que c'est une

variable formelle. On ne déclare pas les variables formelles.

Par contre, la variable a est utilisée dans le corps du programme. C'est elle qui contient

la valeur dont on souhaite connaître le cube. Pour cette raison a est appelée variable

effective.


"cube(a)" représente la valeur obtenue en exécutant les instructions décrites dans la

déclaration de la fonction "cube" lorsqu'on y remplace x par la valeur de a. C'est donc

un nombre. Il faut donc soit le mémoriser dans une variable (c:=cube(a)), soit

l'afficher,... mais "cube(a);" n'est pas une instruction !

Remarque

La variable effective à laquelle on souhaite appliquer la fonction (a) doit

nécessairement avoir le même type que la variable formelle qui permet de définir la

fonction (x).

2) Fonction puissance

Généralisons la fonction cube de façon à ce qu'elle permette de calculer n'importe

quelle puissance entière d'un nombre réel. program puissances;

var x : real;

n : integer;

On va calculer xn

function puissance(base : real; exposant:

integer):real;

var i : integer;

p : real;

begin

if exposant <> 0 then

begin

p:=1;

for i:=1 to exposant do

p:=p*base;

end

else p:=1;

puissance:=p;

end;

La fonction puissance dépend de deux

arguments : une base réelle et un exposant

entier

i est une variable qui ne sert que de

compteur, p permet de calculer les

puissances successives de la base.

Cette affectation donne la valeur de la

fonction puissance begin

write('Entrer la base'); read(x);

write('Entrer l''exposant');

read(n);

write(x,' ^ ', y, ' = ',p(x,n))

end.

Introduction des variables effectives (x et n)

Calcul et affichage de xn (puissance(x,n)).

Les variables i et p ne sont nécessaires qu'au moment du calcul de xn. Les valeurs que

ces variables prennent ne sont jamais utilisées dans le reste du programme. Par


conséquent, on les déclare dans la fonction. On appelle ces variables des variables

locales. Leurs valeurs (et même leur existence) ne sont connues qu'au moment de

l'exécution de la fonction. Dès que le programme quitte la fonction, ces variables se

"volatilisent".

Au contraire, les variables x et n sont utilisées dans le corps du programme. Leur valeur

(à fortiori leur existence) est connue à tout moment de l'exécution. On les appelle

variables globales.

Remarque

Lors de l'appel de la fonction puissance (x,n), on ne peut pas permuter les deux

paramètres (puissance (x,n) … puissance (n,x) ). Non seulement au point de vue

mathématique, mais aussi du point de vue informatique (différence de type entre les

variables).


CHAPITRE VI - PROCÉDURES

VI.1. UTILITÉ

Les procédures sont des sous-programmes. On peut en créer chaque fois qu'une tâche doit

être décomposée en sous-tâches ou lorsqu'une action demande l'introduction de plusieurs

instructions.

Exemple

On peut construire une procédure

- qui demande l'introduction d'un caractère au clavier et jusqu'à ce que 'O' ou 'N'

soit entré,

- qui affiche tel ou tel ensemble de solutions,

- qui calcule telle ou telle variable,...

Contrairement aux fonctions qui ne peuvent servir qu'à calculer une valeur, la liste des tâches

que peuvent réaliser les procédures est illimitée. Toutes les fonctions peuvent être

transformées en procédures, l'inverse n'est pas exact.

VI.2. CONSTRUCTION

La structure d'une procédure la même que celle d'un programme. On y trouve d'abord

- la ligne d'en-tête (obligatoire) commence par le mot "procedure" (et non par

program) suivi du nom de la procédure et éventuellement d'une liste de

paramètres (voir plus loin),

- la partie déclarative contient les déclarations de constantes, de variables

(facultatives),... et même d'autres procédures ou fonctions.

- le corps de la procédure commence par begin, finit par end; et contient les

instructions à exécuter.

Voir la syntaxe dans un paragraphe ultérieur.

VI.3. APPEL D'UNE PROCEDURE

Pour demander l'exécution d'une procédure, il faut l'appeler dans le corps du programme ou

dans le corps d'une autre procédure. program addition_durees;

uses crt;

var h1,m1,s1,h2,m2,s2,ht,mt,st : byte;

Déclaration des variables

utilisées dans le corps du

programme (variables


effectives et globales) procedure introduire_duree (var h,m,s : byte);

begin

write('Introduire le nombre d''heures');

readln(h);

write('Introduire le nombre de minutes');

readln(m);

write('Introduire le nombre de secondes');

readln(s);

end;

procedure d'introduction de

l'heure : les variables h,m,s

sont formelles A noter :

le"var"qui les précède dans

la ligne d'en-tête. Il est

indispensable car les variables

sont initialisées au sein de la

procédure (la procédure a pour

but de modifier la valeur des

variables). procedure affiche_duree (h,m,s : byte);

begin

writeln(h,' heures ', m,' minutes ',s,'

secondes');

end.

procedure d'affichage : les

variables h,m,s sont formelles.

A noter : il n'y a pas de

"var" devant ces variables

dans la ligne d'en-tête. En

effet, cette procédure affiche

trois nombres séparés par du

texte, elle ne modifie donc pas

la valeur des variables qui lui

sont proposées. procedure additionne_durees (h1, m1 ,s1, h2, m2,

s2 : byte; var ht, mt, st : byte);

begin

st:= (s1 + s2) mod 60;

mt:= (m1 + m2 + (s1+s2) div 60) mod 60;

ht:= (h1 + h2 + (m1 + m2) div 60);

end;

procedure de calcul : les

variables indiquées sont

formelles. A noter : il n'y a

pas de "var" devant les 6

premières variables (ce sont

les données), il y a un "var"

devant les trois dernières

variables (ce sont les

résultats). begin

Writeln('Première durée');

introduire_duree (h1,m1,s1);

Writeln('Deuxième durée');

Introduction des données. Les

variables h1,m1,s1 et

h2,m2,s2 sont effectives : ce


introduire_duree (h2,m2,s2);

additionne_durees(h1,m1,s1,h2,m2,s2,ht,mt,

st);

affiche_duree (h1,m1,s1);

affiche_duree (h2,m2,s2);

affiche_duree (ht,mt,st);

end.

sont les variables auxquelles

s'applique réellement le

programme.

Calcul.

Affichage des résultats (la

même procédure est utilisée

trois fois avec des variables

différentes).

VI.4. TRANSMISSION DE PARAMÈTRES

L'action de certaines procédures dépend parfois des résultats obtenus par d'autre(s)

procédure(s) ou par le programme principal. On appelle ces grandeurs des paramètres.

PASCAL considère que ces paramètres sont des variables. On les signale dans la ligne d'en-

tête, derrière la nom de la procédure.

Le problème qui se pose est de communiquer certaines valeurs obtenues par une procédure à

d'autres procédures ou au programme principal.

On peut transmettre ces variables de deux façons différentes : par "valeur" et par "variable".

Si une procédure dépend de plusieurs paramètres, on peut choisir un mode de transmission

pour chacun d'entre eux.

Pour transmettre un paramètre par variable, il suffit d'écrire la mot "var" devant son nom dans

la liste des paramètres. Si le mot "var" n'est pas présent, le paramètre est transmis par valeur.

a) Transmission par valeur

Lors de la transmission d'un paramètre par valeur, toute modification apportée à la valeur du

paramètre au sein de la procédure est annulée lors du passage à l'extérieur de la procédure.

En fait, lors de l'appel de la procédure, il y a création en mémoire locale d'une nouvelle

variable qui prend la valeur transmise par le programme principal ou la procédure appelante.

On utilisera donc de préférence ce mode de transmission pour des variables dont on ne

souhaite pas modifier la valeur au sein de la procédure.

b) Transmission par variable

Lors de la transmission d'un paramètre par variable, toute modification apportée à la variable

au sein de la procédure est transmise lors du passage à l'extérieur de la procédure.


Ce mode de transmission est donc obligatoire dès qu'on souhaite modifier la valeur du

paramètre au sein de la procédure (à fortiori si on initialise le paramètre).

Si on considère l'exemple de la page précédente, on constate que la procédure

"introduire_duree" dépend de trois paramètres h,m,s transmis par variable (car il y a un "var"

devant). Par conséquent, la modification de la valeur des paramètres est exportée. Si on

utilisait l'autre mode de transmission, cette procédure n'aurait plus aucune utilité, puisque les

valeurs que l'on donnerait aux paramètres ne serait pas transmises au corps du programme.

En considérant la procédure "affiche_duree;" du même exemple, on constate que les trois

paramètres h,m,s dont elle dépend sont transmis par valeur. Ce mode est correct puisque le

but de cette procédure est d'afficher les valeurs des variables. On ne doit donc pas modifier

celles-ci. Si on utilisait l'autre mode de transmission, cette procédure fonctionnerait encore.

c) Variable formelle et variable effective

Les variables h,m,s qui sont utilisées pour définir les procédures "introduire_durée" et

"affiche_durée" ne jouent pas un vrai rôle. Elles sont là uniquement pour décrire la tâche que

doit accomplir la procédure. Seule le type des paramètres (ici, byte) et l'ordre des paramètres

a de l'importance. On dit que les variables sont formelles. On ne déclare pas les variables

formelles.

Par contre, les variables h1,m1s1 et h2,m2,s2 sont utilisées dans le corps du programme. Ce

sont elles qui contiennent effectivement les valeurs. Pour cette raison elles sont appelées

variables effectives.

Remarques

(1) les variables effectives auxquelles on souhaite appliquer la procédure doivent

nécessairement avoir le même type que les variables formelles qui permettent de

définir la procédure. Elles doivent également être dans le même ordre.

(2) les paramètres utilisés par la procédure "additionne_durées" ont les mêmes noms

que les variables effectives. Cela n'est pas gênant. PASCAL distingue

parfaitement la variable h1 déclarée en début de programme et utilisée dans le

corps du paramètre h1, variable formelle de la procédure, utilisée dans la

procédure.


d) Variable locale et variable globale

On peut déclarer et utiliser des variables locales qui ne sont accessibles qu'à l'intérieur de la

procédure et ignorées à l'extérieur. Il suffit de les déclarer dans la partie déclarative de la

procédure.

Par opposition, les variables déclarées dans la partie déclarative du programme sont dites

globales, c'est-à-dire qu'elles sont accessibles à n'importe quel endroit du programme, à

l'intérieur comme à l'extérieur des procédures. PASCAL fait la distinction entre une variable

locale et une variable globale portant le même nom (règle d'homonymie).

VI.5. SYNTAXE DES PROCEDURES

Comme les exemples le montrent, la syntaxe utilisée dans la ligne d'en-tête permet de

signaler à PASCAL le mode de transmission des paramètres. La syntaxe complète de cette

ligne d'en-tête est décrite dans le schéma suivant :

procedure identificateur ;(

identificateur

var

: type de variable ;

,

)

Comme on peut le voir sur ce dessin, il est possible de transmettre plusieurs paramètres entre

sous-programmes et programme principal. Il suffit de séparer les variables par des ";".

Exemple procedure machin (var a : real; car : char; var i : integer);

Dans l'exemple ci-dessus, les paramètres a -réel- et i -entier- sont transmis par variable

et la variable car -caractère- par valeur.

Un raccourci est toutefois utilisé lorsqu'on veut transmettre plusieurs paramètres de

même type de la même façon.

Exemple procedure machin (var a,b : real; c : real; var vrai : boolean);

Dans cet exemple, a et b sont des paramètres réels transmis par variable, c -réel aussi-

est transmis par valeur.

Remarque : types de paramètres

Il est important de constater que seules des variables de type prédéfini simple (real,

integer, char, boolean) peuvent être ainsi transmises, soit par valeur, soit par variable.

Pour les types prédéfinis composés (string, array,...), il faut recourir à une déclaration


de type. L'étude de ces types prédéfinis composés sont l'objet du chapitre suivant

(déclaration de type).


CHAPITRE VII - LES TYPES PRÉDÉFINIS

VII.1. VARIABLES ALPHANUMÉRIQUES

On appelle variable alphanumérique une variable pouvant prendre pour valeur un ou

plusieurs caractères qu'ils soient numériques (les opérations arithmétiques n'étant pas valables

dans ce cas) ou autres. En fait, il s'agit de tous les caractères utilisés en informatique et qui

sont répertoriés dans le code ASCII. Selon le nombre de caractères que ces variables peuvent

contenir, on distingue deux types prédéfinis de variables alphanumériques : les caractères

(CHAR) et les chaînes de caractères (STRING).

a) Codage des informations

L'ordinateur étant constitué de circuits électriques et/ou électroniques, le seul moyen de

communication entre ses différents éléments est l'envoi de signaux électriques. Il perçoit alors

des variations de courant que l'on symbolise par 0 : le courant ne passe pas, 1 : le courant

passe.

On appelle bit (BInary digiT) une variable pouvant prendre les valeurs 0 et 1. En utilisant un

bit, on peut reconnaître 2 symboles différents. En prenant deux bits, on en distingue 4 : 00,

01, 10 et 11. A l'aide de trois bits, 8 informations différentes sont reconnaissables... Et ainsi

de suite, à l'aide de n bits, on peut distinguer 2n informations.

Un ensemble de 8 bits forme un octet ou un byte (en anglais). C'est l'unité d'information qui

correspond à un caractère. On dit qu'un caractère est codé sur un octet ou sur un byte.

L'octet est l'unité d'information car il faut 8 bits pour distinguer tous les caractères (256)

utilisés en informatique. En effet,

- notre alphabet comporte 26 lettres tant majuscules que minuscules,

- nous comptons à l'aide de 10 chiffres.

- les signes de ponctuation (, ; . { " ! } ' [ : ? ] ) au nombre d'une douzaine,

- les 10 signes d'opérations mathématiques (+ * - / ^ < > =),

- quelques signes divers (\ | £ @ # & % $ ~ ¨ ° ² §),

- quelques caractères spéciaux de l'informatique (<SPACE>, <DEL>, <BEEP>,

<BACKSPACE>, <RETURN>, <LINE FEED>,...),

- les caractères accentués propres au français (é è ê ë à â î ô û ï ù),

- des codes graphiques ( ),

- des lettres grecques (α, β, γ, ∆, ϕ, ω, λ, µ, ν, …)


- des caractères mathématiques ( ± ÷ ),

on arrive à 256 caractères distincts, numérotés de 0 à 255

La lettre "A" porte le numéro 65, "B" le 66, ... et "Z" le code 90. Par contre, les lettres

minuscules ont des codes compris entre 97 et 122. Tous les caractères cités plus haut sont

donc titulaires d'un nombre compris entre 0 et 255; ce nombre étant écrit à l'aide de 0 et de 1,

càd en binaire.

Par exemple, l'octet 00100001 représente le nombre 65 en binaire. L'ordinateur traduit alors

cette séquence en la lettre "A" à l'aide du code ASCII (American Standard Code for

Instruction Interchange). Il s'agit d'un code utilisé universellement dans les communications

entre ordinateurs ou entre un ordinateur et ses périphériques.

Signalons encore que c'est grâce à ce code ASCII que l'ordinateur "connaît" l'ordre

alphabétique. En effet, il place "A" avant "B" car le code ASCII de A est plus petit que celui

de "B". De même, "Z" (dont le code est 90) précède "a" (de code 97) dans l'alphabet de

l'ordinateur.

b) Variables caractères

Les variables de type caractère sont déclarées par CHAR. Une variable de ce type peut

prendre pour valeur n'importe quel caractère du code ASCII. Ainsi, var a,b,c : char;

a:='A';

b:=a;

c:=chr(55);

sont licites. On peut introduire une valeur dans une variable caractère de trois façons

différentes :

- soit on donne la valeur explicite entre apostrophes;

- soit on donne la valeur obtenue par une opération sur une autre variable caractère ou

sur une chaîne de caractères (voir paragraphe D);

- soit par son code ASCII, à l'aide de la fonction CHR (voir paragraphe 4).

Grâce au code ASCII, nous pouvons comparer deux variables de type caractère différentes :

on peut introduire un ligne du type IF a>b THEN ...

si a et b sont deux variables CHAR. Pour l'ordinateur, une variable de type caractère est

supérieure à une autre si la même relation existe entre leurs codes ASCII.


c) Chaînes de caractères

On peut introduire plusieurs caractères dans une même variable; on parle alors d'une chaîne

de caractères. On déclare alors la variable comme STRING. L'utilisation de ce type est

généralement suivie de la déclaration de la taille ou longueur de la chaîne : c'est-à-dire le

nombre maximal de caractères qu'elle peut contenir. Ce nombre est généralement différent de

1 (car on utilise plutôt le type CHAR) et a pour valeur maximale 255. L'utilisation de STRING

sans déclaration de taille donne à la variable la taille maximale par défaut. Les exemples, var a,b : string[10];

c : string[20];

d : string[12];

a:='bonjour';

b:='vous tous';

c:=a+b; d:=c;

sont licites. On peut introduire une valeur dans une chaîne de caractères par une assignation

du même type que celle des variables de type caractère ou par une opération sur une ou

plusieurs autres chaînes de caractères (ces opérations -concaténation, par exemple- sont

décrites plus loin).

On désigne le ième caractère d'une chaîne de la façon suivante : si a est la variable déclarée

dans l'exemple ci-dessus, a[3] est le caractère "n". En général, a[i] désigne le ième caractère de

la chaîne a. On peut donc écrire "write (a[i]);".

On peut également comparer deux chaînes de caractères, l'ordinateur utilise le code ASCII.

Remarques

Le nombre de caractères réellement présents dans une variable "chaîne de caractères"

ne doit pas obligatoirement être égal à la taille déclarée. Attention cependant, si le

nombre de caractères présents est plus petit que la taille, il arrive que PASCAL

"complète" la chaîne avec des caractères farfelus. Par contre, si on essaie de donner à

une variable de type STRING une valeur constituée de plus de caractères que la taille

déclarée, PASCAL tronque la chaîne de caractères après le nombre de caractères

déclaré. La variable d de l'exemple ci-dessus a effectivement pour valeur 'bonjourvous'.

Le caractère chaîne[0] (caractère numéro zéro de <chaîne>) existe. Cependant, il

contient toujours le caractère dont la code ASCII a pour numéro la longueur de la

chaîne de caractères.


VII.2. OPÉRATEURS, PROCÉDURES et FONCTIONS

Dans ce paragraphe, <nombre> et <position> représentent soit un nombre entier, soit une

variable entière; <caractère> est soit un caractère, soit une variable de type CHAR; <chaîne>

désigne soit une chaîne de caractères, soit une variable de type STRING.

a) Opérateurs

+ : opérateur qui concatène deux variables alphanumériques, c'est-à-dire construit la

nouvelle chaîne obtenue en accolant les caractères de la seconde chaîne à ceux de la

première. En reprenant l'exemple du paragraphe 3, la variable c a pour valeur

'bonjourvous tous'. (L'ordinateur n'insère pas de blancs). Attention, cette "addition" n'est pas

commutative.

b) Fonctions

1) chr

Syntaxe : chr(<nombre>). Fonction de type char : donne le caractère dont le code

ASCII est <nombre>.

Exemple : var a : char;

a := chr(66);

donne à la variable a la valeur 'B'.

2) Ord

Syntaxe : ord (<caractère>). Fonction de type integer : donne le code ASCII de

<caractère>.

Exemple : var n : integer;

n := ord ('E');

donne à la variable n la valeur 69.

3) Length

Syntaxe : length (<chaîne>). Fonction de type integer : donne le nombre de

caractères contenus dans <chaîne>.

Exemple :

En utilisant l'exemple ci-dessus, var longueur : integer;

longueur := length (c);

donne à la variable c la valeur 17.


4) Copy

Syntaxe : copy (<chaîne>,<position>,<nombre>). Fonction de type string : donne la

chaîne de caractères obtenue en considérant les <nombre> caractères de <chaîne> à

partir de <position>.

Exemple :

Toujours avec l'exemple ci-dessus : var partie : string[10];

pos,nombre : integer;

partie := copy (c,5,4) ;

donne à la variable partie la valeur 'ourv'.

5) Upcase

Syntaxe : Upcase (<caractère>). Fonction de type char : transforme toute lettre

minuscule en majuscule. Attention, cette fonction n'agit pas sur les caractères

accentués, les chiffres, les signes de ponctuation,...

Exemple var a,b: char;

a := 'e' ; b:=upcase(a);

donne à la variable b la valeur 'E'.

c) Procédures

1) Delete

Syntaxe : delete (<chaîne>,<position>,<nombre>). Procedure qui efface les

<nombre> caractères de <chaine> placés à partir de <position>.

Exemple a:='bonjour'; delete (a,3,2);

transforme a en 'boour'.

2) Insert

Syntaxe : insert (<chaîne>,<chaîne_ajout>,<position>). Procédure qui insère la

chaîne de caractères <chaîne_ajout> au caractère <position> au sein de <chaîne>.

Exemple

Si a désigne le texte tronqué de l'exemple précédent, ajout:='nj'; insert (a,ajout,3);

rend à la variable a la valeur 'bonjour'.


3) Val

Syntaxe : val(chaîne, nombre, code). Procédure qui convertit <chaîne> en un nombre

et place le résultat dans <nombre>. <chaîne> doit représenter un nombre (composée de

chiffres, du point décimal, du "e" des puissances de 10, du signe + ou -). Code vaut 0 si

aucune erreur n'est détectée, le numéro du caractère de chaîne ayant déclenché l'erreur

sinon.

4) Str

Syntaxe : str(nombre, chaîne). Procédure qui convertit une valeur numérique

<nombre> en chaîne de caractères <chaîne>. On peut préciser le format comme pour

l'instruction write.

VII.3. TABLEAUX

a) Introduction

Voici un programme destiné à faire additionner 10 nombres aléatoires à l'aide d'une boucle,

on peut utiliser le programme suivant : program addition;

var t,i,n : integer;

begin

randomize;

t:=0;

for i:=0 to 9 do

begin

n:=random(100);

t:=t+n;

end;

write(t);

end.

La variable n va prendre successivement pour valeur les nombres aléatoires. Successivement,

cela veut dire qu'à chaque exécution de l'ordre "n:=random...", la valeur de n est remplacée

par une nouvelle valeur; l'ancienne étant oubliée, inaccessible.

Or, il se peut que nous ayons besoin une deuxième fois des valeurs déjà mémorisées

(exemple : calcul de la moyenne et de l'écart-type, recherche du maximum, tri,...). Cela est

impossible actuellement.

Une autre solution serait d'utiliser autant de variables qu'il y a de valeurs à traiter (a,b,c,d,...).

Mais on sait qu'elle n'est pas réalisable si on doit utiliser de nombreuses valeurs différentes.


Il faudrait donc arriver à concilier les deux solutions :

- utiliser autant de variables différentes qu'il y a de données,

- pouvoir accéder aux valeurs à l'aide d'une boucle.

b) Définitions

La solution se trouve dans les variables indicées ou tableaux. Un tableau est un type

structuré. Une variable de ce type comporte un nombre fixe d'éléments ayant tous le même

type, le type de base.

Ce type de base peut-être quelconque : entier, réel, caractère, chaîne de caractères,... ou

même tableau.

Il y a plusieurs types de variables indicées, les variables à une dimension appelées listes ou

vecteurs, celles à deux dimensions, nommées matrices et les autres, à plusieurs dimensions,

beaucoup plus rarement utilisées.

Dans un premier temps, nous étudierons les vecteurs. Ensuite, nous passerons à l'étude des

matrices.

c) Vecteurs

On appelle vecteur une variable indicée à une dimension. Les éléments d'un vecteur sont ses

composantes.

La déclaration d'une variable de type vecteur se fait comme ceci :

Array Index Of Type de base ; ] [

où index donne la dimension du vecteur. Cet index donne la plus petite et la plus grande

valeur acceptables pour l'indice du tableau.

Exemple

Toutes les déclarations ci-dessous sont correctes : var a: array [1..100] of integer;

b: array [-5..5] of char;

c: array ['a'..'z'] of integer;

Elles permettent de définir respectivement a comme vecteur de 100 entiers -dont

l'index parcourt les valeurs entières comprises entre 1 et 100-, b comme vecteur de 11

caractères -dont l'index parcourt les valeurs entières comprises entre -5 et 5- et c en

temps que vecteur de 26 entiers -dont l'indice parcourt les lettres comprises entre 'a' et

'z'.


Chaque élément du tableau est accessible : a[1] désigne le premier entier enregistré

dans a, c['f'] la sixième composante de c.

On peut se représenter un vecteur comme un building. Ainsi, lorsqu'on déclare n : array [1..20] of real;

n est le nom du building (le fait qu'il soit couché ne change rien au fond de l'histoire).

n[1] n[2] … n[20]

Si on utilise un vecteur n, le problème rencontré ci-dessus se résout facilement : program addition;

var t,i : integer;

n : array [0..9] of integer;

begin

randomize;

t:=0;

for i:=0 to 9 do

begin

n[i]:=random(100);

t:=t+n[i];

end;

write(t);

end.

A chaque exécution du corps de la boucle, l'ordinateur tire une valeur au hasard et la place

dans une des cases de la variable n.

Remarques

(1) Notons qu'il faut absolument recourir à une boucle pour créer chacune des

composantes une par une. Il est impossible de remplacer la boucle par

n:=random...;2

(2) Si on veut afficher les valeurs des différentes composantes de n, il suffit de

demander l'impression de tous les n[i]. for i:=0 TO 9 do

write (n[i]);

2 On pourrait créer une procédure, contenant une boucle, qui initialiserait le vecteur. On

aurait l'impression que on peut l'initialiser avec une seule instruction.


(3) Il aurait été impossible d'afficher toutes les valeurs après la première boucle

sans les variables indicées.

(4) La seule instruction permettant de gérer les variables indicées en bloc est

l'assignation. Si a et b sont deux variables indicées de même type, l'instruction

"b:=a;" est identique à "for i:=1 to n do b[i]:=a[i];".

d) Matrices

Une matrice est un tableau rectangulaire. Les rangées horizontales sont appelées lignes, les

verticales, colonnes. Par exemple

2 -5 4

8 0 -4

est un tableau à 2 lignes et 3 colonnes. L'intersection d'une ligne et d'une colonne s'appelle un

élément.

On déclare une matrice à l'aide de l'instruction suivante :

Array Index1 Of Type de base , ] [ Index2 ;

où index1 et index2 donnent la dimension de la matrice. Ces index donnent, pour chaque

dimension, la plus petite et la plus grande valeur acceptables pour l'indice du tableau.

Exemples

Toutes les déclarations ci-dessous sont correctes : var a: array [1..100,1..50] of integer;

b: array [-5..5,0..30] of char;

c: array ['a'..'z','g'..'h'] of integer;

Elles permettent de définir respectivement a comme matrice de 100 x 50 entiers -dont

les index parcourent les valeurs entières comprises entre 1 et 100 d'une part et 1 et 50

d'autre part-, b comme matrice de 11 x 31 caractères et c en temps que matrice de 26 x

2 entiers.

X[1,1] désigne l'élément de la première ligne et de la première colonne, X[I,J] celui de la ième

ligne et de la jème colonne.

Pour lire ou afficher la valeur de tous les éléments d'une matrice, il faut travailler sur chaque

élément séparément. Cela se fait par l'intermédiaire d'une double boucle sur i et sur j.


Exemple

Pour initialiser un tableau de L lignes et C colonnes, on doit donner les instructions

for i:=1 to L do

for j:=1 to C do

x[i,j]:=random(100);

Attention, l'ordre des boucles détermine l'ordre de lecture des valeurs. Ici, on lit le

tableau "horizontalement" ou ligne par ligne (càd tous les éléments de la ligne 1, puis

de la ligne 2,...). Si on permute les deux boucles, on va le lire "verticalement" ou

colonne par colonne (càd tous les éléments de la première colonne, puis de la

deuxième,...). Pour l'impression d'une matrice, on n'a pas le choix. Il faut afficher les

éléments ligne par ligne (sauf utilisation de la procédure gotoxy(x,y)).

Toutes les remarques faites à propos des vecteurs restent vraies pour les matrices.

VII.4. LES FICHIERS

a) Introduction

Les fichiers sont l’outil qui permet au programmeur de sauvegarder des données sur disque.

Cela est évidemment très important en pratique. Il ne faudrait pas qu’une panne de courant

déclenche la perte des données que l’ordinateur doit traiter. Or lors de l’exécution d’un

programme, le seul endroit où sont stockées les données est la mémoire vive.

Il existe de nombreux type de fichiers, que l’on peut classer d’après leur organisation

(séquentiels, à accès direct, ...). Les fichiers qui sont abordés dans ce chapitre sont du type

“séquentiel”. Cela veut dire que les données qu’ils contiennent sont sauvegardées les unes

derrière les autres sur la disquette.

Cette organisation est très simple à comprendre. L’utilisation de tels fichiers est cependant

déconseillée dans le cas de fichier de grande taille car est très lente. En effet, pour accéder à

la nème donnée, l’ordinateur doit lire les n-1 précédentes.

Enfin, chaque donnée sauvegardée dans un fichier est appelée en informatique un

enregistrement. Généralement, un fichier contient des données qui ont toutes le même type

(ou alors, il s’agit d’un simple fichier texte).

b) Création d’une fichier séquentiel

Pour créer un fichier séquentiel, il faut


1) Définir le type “fichier”

Cela se fait à l’aide d’une déclaration de type type fichier = file of ....

Où ... représentent un type de variable prédéfini (real, integer, char,...) ou déclaré dans une

autre déclaration de type3.

Cette déclaration de type n’est pas obligatoire, sauf si on souhaite utiliser des fichiers comme

paramètres dans des procédures (car les paramètres des procédures ne peuvent être de type

composé (file...of) mais doivent être de type simple (fichier)).

2) Définir une variable de type fichier

Cela se fait à l’aide d’une déclaration de variable classique var f: fichier;

3) Nommer le fichier réel

Il faut tout d’abord associer à f le nom du réel du fichier sur le disque ou la disquette. Cela se

fait à l’aide de l’instruction assign.

Exemple :

assign (f,’a:fic’) signale que chaque fois que l’on utilise la variable f,

l’ordinateur doit agir sur le fichier “fic” présent dans le lecteur a: .

Le nom du fichier réel peut être précédé du nom du lecteur de destination (a:, c:,...) et du

chemin (sous-répertoire). Eventuellement, il peut-être suivi d’une extension (3 caractères).

Exemple assign (f,’a:\fichiers\fic.txt’).

Il est préférable de conserver la syntaxe des noms au format 8.3 (8 caractères pour le nom 3

pour l’extension). Si on essaie de donner un long nom au fichier, Pascal abrège le nom du

fichier au 8ème caractère.

4) Créer le fichier

Cela se fait à l’aide de l’instruction rewrite.

Exemple

Si l’instruction assign citée dans le paragraphe précédent a été insérée auparavant,

l’instruction rewrite(f) crée le fichier “fic” sur la disquette.

3Voir création de type personnalisé (record)


Si le fichier “fic” se trouvait déjà sur la disquette, il est automatiquement supprimé et

remplacé par un nouveau fichier.

Le deuxième effet de l’instruction rewrite est d’ouvrir le fichier en écriture (pour

permettre d’y inscrire des données).

c) Ouvrir le fichier

Chaque fois que l’on veut lire ou écrire une donnée dans le fichier, il faut que celui-ci soit

ouvert. cela se fait à l’aide de l’instruction reset.

Exemple

reset(f) ouvre le fichier f.

Dès que le fichier est ouvert, le prochain ordre d’écriture ou de lecture s’applique au

premier enregistrement du fichier.

Attention, si on écrit une nouvelle donnée à ce moment, le premier enregistrement est

effacé au profit de la nouvelle donnée.

d) Lecture et écriture dans un fichier

Pour lire ou écrire une donnée x dans le fichier f, il faut employer respectivement à l’aide de

read(f,x) ou write(f,x).

Attention, il est impératif que x soit une variable du même type que celui déclaré lors de la

déclaration de f. Si f est un fichier de char, il ne peut pas enregistrer une variable de type

entier, etc...

e) Fermeture du fichier

Pour fermer un fichier, il faut utiliser l’instruction close. Par exemple, close(f). Cette

instruction permet à l’ordinateur d’insérer le code de fin de fichier (ce qui permet d’éviter des

erreurs de lecture ultérieures). Ne pas fermer un fichier est assez dangereux pour les données.

f) Déplacement à la fin du fichier

Si on veut parcourir tout le fichier (par exemple pour compter le nombre d’enregistrements),

on ne peut recourir à une boucle du type FOR puisque le nombre d’enregistrements n’est pas

nécessairement connu. On utilise alors une boucle du type while not eof(f) do

dont la traduction littérale est “tant que pas fin de fichier f”.

Eof(f) est une expression booléenne qui est fausse si l’enregistrement actif n’est pas la fin

du fichier et vraie sinon.


On peut aussi utiliser repeat.... until eof(f).

VII.5. LE TYPE ENREGISTREMENT

Le type enregistrement (record) est un type particulier. Il s’agit d’une structure

personnalisable de variables. Par exemple, si on veut désigner une personne, il faut connaître

au moins son nom, son prénom, son sexe,... le type enregistrement permet de définir des

types de variables parfaitement adaptées à cette contrainte. En effet, l’exemple ci-dessus se

présente sous la forme d’une déclaration du type type personne = record

Nom : string[15];

Prenom : string[15];

Homme : boolean;

end;

var p : personne;

Cette déclaration signale qu’une variable de type “personne” est composée de trois parties :

une partie “nom” (chaîne de 15 caractères), une partie “prenom” (idem) et une partie

“homme” (booléenne).

La variable p est déclarée comme de type “personne”. Ses différentes parties se désignent

respectivement par p.nom, p.prenom et p.homme.

Il est possible de donner une valeur à chacune de ces parties séparément (par instruction du

type p.prenom = ‘Jules’ ou p.homme:=true)

De plus, il est impossible d’utiliser les instructions write et read (dans le but d’un affichage à

l’écran ou d’une lecture au clavier) pour des variables de type enregistrement. Il faut afficher

(ou lire) chaque partie séparément (ex : write (p.nom, p.prenom, p.homme)).

Si on veut, il est possible de créer une procédure “ecrire_personne” s’appliquant à une

variable de type “personne” et qui demande l’exécution de l’instruction ci-dessus).

Par contre les instructions write et read utilisées pour lecture ou écriture dans un fichier de

“personne” sont utilisables (voir paragraphe sur fichiers séquentiels).


VII.6. EXERCICE

a) Vecteurs

1) Construire un programme qui calcule la moyenne (µ) et l'écart type ( σ ) d'un ensemble

de dix nombres entiers introduits au clavier.2 2 2

1 2( ) ( ) ( )nx x xn

µ µ µσ − + − + + −= � .

2) Construire un programme qui simule N lancers de dés, compte les fréquences et les

imprime.

3) Construire un programme qui recherche le maximum d'un ensemble de nombres donnés

(aléatoires compris entre 1 et 99).

4) Construire un programme qui recherche le maximum et le minimum d'un ensemble de

nombres donnés (aléatoires compris entre 1 et 99).

5) Construire un programme qui trie un vecteur de 100 nombres entiers aléatoires compris

entre 1 et 99 par l'algorithme suivant : on recherche le maximum et on le place en

dernière position, l'élément qui était en dernière position prend la place qu'occupait le

maximum. Puis on recommence en cherchant le maximum des 99 premiers éléments du

vecteurs...

6) Construire un programme qui trie un ensemble de 100 nombres en améliorant

l'algorithme précédent : on cherche le minimum et le maximum, on place ces deux

nombres en première et dernière place, on cherche le minimum et la maximum des

nombres 2 à 98...

7) Construire un programme qui trie un ensemble de nombre par l'algorithme suivant : on

compare les deux premiers éléments, s'ils sont dans le bon ordre, on les garde, sinon, on

les permute; on compare le deuxième et le troisième...

b) Chaînes de caractères

1) Construire un programme qui demande un chaîne de caractères au clavier et donne le

nombre de fois que la lettre "A" s'y trouve.

2) Construire un programme qui demande une chaîne de caractères au clavier et imprime

le nombre d'exemplaires de chaque lettre qui s'y trouve.


3) Construire un programme qui demande un chaîne de caractères au clavier et donne le

nombre de mots qu'elle contient. (On compte un mot par " " rencontré plus un pour le

point).

4) Construire un programme qui construit une chaîne de caractères au hasard, l'écrit à

l'endroit puis à l'envers.

5) Construire un programme qui réalise le jeu du pendu. L'ordinateur prend connaissance

d'un mot : soit un joueur introduit le mot au clavier, soit il tire un mot au hasard dans un

fichier séquentiel. Puis il faut le deviner :

(1) l'ordinateur affiche les lettres des extrémités et remplace les autres lettres par un

"-",

(2) demande une lettre au clavier et la compare aux lettres inconnues du mot de

départ,

(3) imprime les lettres dont le joueur a deviné la présence dans le mot au bon endroit,

(4) fait aussi apparaître les tentatives manquées,

(5) compte le nombre de tentatives,...

(6) Option : On peut aussi, dès le départ, afficher les première et dernière lettres ainsi

que les lettres intérieures identiques).

6) Construire un programme qui réalise un jeu de MASTER MIND avec des mots. Un

joueur introduit un mot au clavier, l'analyse puis répond au deuxième joueur qui essaie

de deviner. A chaque tentative, l'ordinateur donne le nombre de lettres bien mises et le

nombres de lettres présentes mais mal placées.


CHAPITRE VIII - PROCÉDURES GRAPHIQUES

VIII.1. INTRODUCTION

Les notions développées dans ce paragraphe sont applicables à la version sous DOS. Elles

nécessiteraient des modifications pour le turbo pascal sous windows. Au Pascal "standard",

Turbo Pascal a ajouté un certain nombre de procédures, dont des procédures graphiques.

Nous en donnons un aperçu dans ce chapitre. Toutes les procédures et fonctions qui

interviennent dans cette annexe ne nécessitent que l'insertion de uses graph, drivers;

dans l'en-tête du programme.

Cette instruction vérifie la présence des fichiers GRAPH.TPU et DRIVERS.TPU sur le

disque dur. Pascal y recherchera les procédures graphiques s'il en a besoin.

VIII.2. INITIALISATION DE L'ÉCRAN GRAPHIQUE

L'utilisateur doit prévenir Pascal qu'il va afficher des graphiques. Cela peut se faire en

utilisant la procédure suivante : procedure init;

var graphdriver,graphmode:integer;

begin

graphdriver:=detect;

detectgraph(graphdriver,graphmode);

initgraph(graphdriver,graphmode,'c:\tp\bgi');

end;

où

- graphdriver:=Detect; est l'instruction qui détecte le type de carte

graphique de l'ordinateur;

- detectgraph(graphdriver,graphmode); détecte le mode d'utilisation de la

carte graphique;

- Initgraph (graphdriver, graphmode, 'c:\tp\bgi'); initialise l'écran

en mode graphique.

L'écran est alors composé de pixels dont le nombre dépend de la résolution de la carte

graphique : sur les écrans qui nous sont accessibles, on peut essayer 480 lignes et 640

colonnes (carte VGA). Le pixel de coordonnées (1,1) est celui du coin supérieur gauche de

l'écran, celui de coordonnées (640,480) dans le coin inférieur droit.


VIII.3. REPRÉSENTATION DU DIAGRAMME EN BATONNETS

Voici quelques-unes des principales procédures graphiques de Pascal :

a) Bar

Syntaxe : Bar (x1,y1,x2,y2 : integer);

Permet de tracer (et de remplir) un rectangle dont les points de coordonnées (x1,y1) et

(x2,y2) sont les sommets supérieur gauche et inférieur droit.

b) Bar3d

Syntaxe : Bar3d (x1,y1,x2,y2:integer; profondeur : word, top:boolean);

Permet de tracer un parallélépipède et de colorier la face frontale. Les points de coordonnées

(x1,y1) et (x2,y2) sont respectivement les sommets supérieur gauche et inférieur droit de la

face frontale, "profondeur" est un entier positif qui représente la profondeur du

parallélépipède, et "top" est une variable booléenne demandant la présence ou l'absence de la

face supérieure. Les valeurs prédéfinies de cette variable sont TopOn et TopOff.

La couleur et le motif de coloriage de la face frontale sont définis par la procédure

SetFillStyle, la couleur des autres faces est définie par SetColor.

(1) Set Color

Syntaxe : SetColor (couleur : integer);

Cette procédure définit la couleur des pixels allumés, des droites tracées et du

texte affiché à l'écran ainsi que celle de la face latérale droite du

parallélépipède.

La variable "couleur" peut prendre les valeurs de 0 à 15 (Les dernières

couleurs étant généralement plus vives).

Remarque

Sur des écrans monochromes, seules les valeurs 0 et 1 sont acceptées : 0 = noir

et 1 = blanc.

(2) SetFillStyle

Syntaxe : SetFillStyle (motif,couleur : integer);

Cette procédure définit le mode de remplissage et la couleur de la face frontale

d'un parallélépipède.

"Motif" permet de définir le mode de remplissage : vide, plein, quadrillé, ligné,

à points,.... Les valeurs permises sont comprises entre 0 et 10.


"Couleur" défini la couleur de la même face. Elle peut prendre les mêmes

valeurs que pour la fonction SetColor.

VIII.4. TRACÉ DE LIGNES ET DE POINTS

a) MoveTo

Syntaxe : MoveTo (x,y : integer);

Déplace le curseur sur le point de coordonnées (x,y).

b) MoveRel

Syntaxe : MoveRel (Dx,Dy);

Déplace le curseur sur le pixel se trouvant Dx pixels à droite et Dy pixels au-dessus du pixel

actif.

c) PutPixel

Syntaxe : PutPixel (x,y,couleur : integer);

Allume le point de coordonnées (x,y) avec la couleur spécifiée par le troisième paramètre

(voir paragraphes suivants).

d) LineTo

Syntaxe : LineTo (x,y : integer);

Trace le segment joignant le pixel actif au pixel de coordonnées (x,y)

e) Line

Syntaxe: Line (x1,y1,x2,y2 : integer);

Trace le segment joignant les pixels de coordonnées (x1,y1) et (x2,y2).

VIII.5. AFFICHAGE DE MESSAGES EN MODE GRAPHIQUE

Ces procédures sont nécessaires car l'affichage de texte ne peut se faire à l'aide de

l'instruction write lorsque l'écran est en mode graphique.

a) OutText

Syntaxe : OutText (texte : string);

Cette procédure affiche "texte" à l'endroit où se trouve le curseur.


b) OutText

Syntaxe : OutTextXY (x,y : integer;texte : string);

Cette procédure affiche "texte" au point de coordonnées (x,y).

Remarque

Les fonctions OutText et OutTextXY exigent comme argument soit un texte entre

apostrophes, soit une variable de type caractère ou chaîne de caractères. Il faut donc,

lorsqu'on veut afficher un nombre, le convertir en variable alphanumérique : cela se fait à

l'aide de la procédure str (<nombre>,<chaîne>) qui donne à la variable <chaîne> la chaîne

de caractères construite par les différents chiffres qui constituent <nombre>.

c) SetTextStyle

Syntaxe : SetTextStyle (police,direction : word; taille : integer);

Cette procédure définit les paramètres d'affichage du texte que l'on veut afficher à l'aide des

procédures OutText ou OutTextXY.

• "Police" est un paramètre entier positif compris entre 0 et 4, il définit la

police de caractères utilisée. Les valeurs suivantes donnent pour résultat

0 : Police par défaut 1 : Police triple

2 : Petits caractères 3 : Sans sérif

4 : Gothique

• "Direction" est un paramètre entier positif prenant soit la valeur 0 soit la

valeur 1. La valeur 0 correspond à un affichage de gauche à droite, la valeur

1 à un affichage de bas en haut.

• "Taille" est un paramètre entier positif, compris entre 1 et 10, spécifiant la

taille des caractères. Une taille de 1 correspond à des caractères occupant

une portion d'écran de dimension 8x8 pixels. Une taille 2 à une matrice de

dimension double dans les deux tant en largeur qu'en hauteur.


CHAPITRE IX - TABLE DES MATIÈRES

CHAPITRE I - INTRODUCTION 2 I.1. CHARGEMENT DU TURBO PASCAL 2

I.2. PRÉSENTATION TURBO PASCAL 2

I.3. LA LIGNE DES MENUS 3

I.4. LANGAGE COMPILÉ OU INTERPRÉTÉ 6

I.5. ERREURS DE COMPILATION 7

CHAPITRE II - LES BASES DE PASCAL 9 II.1. DÉFINITIONS 9

II.2. STRUCTURE D'UN PROGRAMME PASCAL 10

II.3. PARTIE DÉCLARATIVE 10

a) Les variables 10

b) Les constantes 13

II.4. LE CORPS DU PROGRAMME 14

a) Affecter une valeur à une variable 14

b) Opérations sur les variables 14

c) Affichage 16

d) Lecture au clavier de plusieurs caractères 17

e) Lecture d'un caractère 18

f) La fonction RANDOM 19

g) Instruction simple et macro-instruction 19

II.5. EXERCICES 20

CHAPITRE III - L'ALTERNATIVE 23 III.1. INTRODUCTION 23

III.2. EXPRESSION BOOLÉENNE 23

a) Comparaison ou test 23

b) Variables booléennes 24

c) Opérateurs logiques 24

III.3. CONDITION 25

III.4. SI ... ALORS ... SINON ... 26

III.5. CHOIX MULTIPLE 26

III.6. CRITÈRES DE DIVISIBILITÉ 27

III.7. EXERCICES 28


CHAPITRE IV - STRUCTURES RÉPÉTITIVES 31 IV.1. INTRODUCTION 31

IV.2. TANT QUE 32

a) Exemple 32

b) Structure 32

c) Deuxième exemple 33

IV.3. RÉPÉTER...JUSQU'À 34

a) Exemple 34

b) Structure 34


IV.4. POUR 36

a) Exemple 36

b) Structure 36


IV.5. ADDITION DE N TERMES DANS UNE BOUCLE 38

IV.6. EXERCICES 39

a) Boucles 39

b) Additions dans une boucle 41

c) Boucles et conditions 42

CHAPITRE V - FONCTIONS 44 V.1. INTRODUCTION 44

V.2. CONSTRUCTION 44

a) Structure 44

b) Exemples 45

CHAPITRE VI - PROCÉDURES 48 VI.1. UTILITÉ 48

VI.2. CONSTRUCTION 48

VI.3. APPEL D'UNE PROCEDURE 48

VI.4. TRANSMISSION DE PARAMÈTRES 50

a) Transmission par valeur 50

b) Transmission par variable 50

c) Variable formelle et variable effective 51

d) Variable locale et variable globale 52

VI.5. SYNTAXE DES PROCEDURES 52


CHAPITRE VII - LES TYPES PRÉDÉFINIS 54 VII.1. VARIABLES ALPHANUMÉRIQUES 54

a) Codage des informations 54

b) Variables caractères 55

c) Chaînes de caractères 56

VII.2. OPÉRATEURS, PROCÉDURES et FONCTIONS 57

a) Opérateurs 57

b) Fonctions 57

c) Procédures 58

VII.3. TABLEAUX 59

a) Introduction 59

b) Définitions 60

c) Vecteurs 60

d) Matrices 62

VII.4. LES FICHIERS 63

a) Introduction 63

b) Création d’une fichier séquentiel 63

c) Ouvrir le fichier 65

d) Lecture et écriture dans un fichier 65

e) Fermeture du fichier 65

f) Déplacement à la fin du fichier 65

VII.5. LE TYPE ENREGISTREMENT 66

VII.6. EXERCICE 67

a) Vecteurs 67

b) Chaînes de caractères 67

CHAPITRE VIII - PROCÉDURES GRAPHIQUES 69 VIII.1. INTRODUCTION 69

VIII.2. INITIALISATION DE L'ÉCRAN GRAPHIQUE 69

VIII.3. REPRÉSENTATION DU DIAGRAMME EN BATONNETS 70

a) Bar 70

b) Bar3d 70

VIII.4. TRACÉ DE LIGNES ET DE POINTS 71

a) MoveTo 71

b) MoveRel 71


c) PutPixel 71

d) LineTo 71

e) Line 71

VIII.5. AFFICHAGE DE MESSAGES EN MODE GRAPHIQUE 71

a) OutText 71

b) OutText 72

c) SetTextStyle 72

CHAPITRE IX - TABLE DES MATIÈRES 73

INFORMATIQUE TURBO PASCAL -...

Documents

Transcript of INFORMATIQUE TURBO PASCAL -...