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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 2
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 3
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 4
(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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 5
(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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 6
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 7
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 8
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 9
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 ";".
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 10
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 11
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 12
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;
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 13
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 14
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 15
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>.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 16
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 17
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 18
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 19
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 20
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− − − ).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 21
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 22
(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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 23
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 24
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
La structure de l'algorithme est donc du type
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 25
4) XOR
La structure de l'algorithme est donc du type
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 26
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;
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 27
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 28
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".
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 29
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 30
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.).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 31
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 32
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 à
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 33
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 :
ALGORITHME PROGRAMME
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 34
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>
ce qui se traduit en Pascal par
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 35
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.
c) Deuxième exemple
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 :
ALGORITHME PROGRAMME
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 36
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.
ALGORITHME PROGRAMME
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>
ce qui se traduit en Pascal par
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 37
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
c) Deuxième exemple
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)) !
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 38
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).
ALGORITHME PROGRAMME
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 39
(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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 40
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 41
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 42
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é.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 43
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 44
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 45
- - 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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 46
"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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 47
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 48
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 49
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 50
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 51
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 52
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 53
de type. L'étude de ces types prédéfinis composés sont l'objet du chapitre suivant
(déclaration de type).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 54
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 (α, β, γ, ∆, ϕ, ω, λ, µ, ν, …)
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 55
- 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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 56
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 57
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 58
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'.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 59
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 60
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'.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 61
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 62
(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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 63
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 64
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)
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 65
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 66
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).
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 67
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 68
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 69
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 70
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 71
"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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 72
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.
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 73
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 74
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
c) Deuxième exemple 35
IV.4. POUR 36
a) Exemple 36
b) Structure 36
c) Deuxième exemple 37
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 75
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
Turbo Pascal : 7ème Math Spéciale AR Liège 1 – Y. Haine 3/10/2004 76
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