MODULE M.M.B.

« Méthodes de Modélisation et de Bioinformatique »

PROGRAMMATION
MISE A NIVEAU

Cours
2002-2003

Claire EDELIST
GENERALITES.................................................................................................................... 3
Objectifs du cours ..................................................................................................................... 3
Définition.................................................................................................................................. 3
Principales étapes pour concevoir un programme......................................................................... 3
Les fautes de programmation ..................................................................................................... 4
Règles de savoir-vivre de la programmation structurée................................................................. 4
1. On ne programme qu'après avoir fait l'analyse : ................................................................. 4
2. Règle de modularité : ....................................................................................................... 4
3. Règle de documentation :................................................................................................. 4
4. Règle de lisibilité :............................................................................................................ 4
5. Règle d'interactivité (ou convivialité) : ............................................................................... 5
6. En Pascal comme en VBA, on écrit en anglais ..................................................................... 5

LES ORDINATEURS ............................................................................................................. 6

Anatomie d’un ordinateur........................................................................................................... 6
Physiologie d’un ordinateur ........................................................................................................ 6
Utilisation de l’ordinateur ........................................................................................................... 6

UN SYSTEME D’EXPLOITATION : LE MSDOS ............................................................................. 7

Définition.................................................................................................................................. 7
Accès au système d’exploitation.................................................................................................. 7
Règles relatives aux noms de fichiers .......................................................................................... 7
Principales commandes du système d’exploitation ........................................................................ 8

ALGORITHMIQUE, ANALYSE ET TURBO-PASCAL .......................................................................... 9

Correspondances en Turbo-Pascal et conventions GNS et RAS ...................................................... 9
Squelette d’un programme ........................................................................................................10
1. Structure........................................................................................................................10
2. En Turbo-Pascal..............................................................................................................11
Les modules ............................................................................................................................11
1. Définition .......................................................................................................................11
2. Réseau de modules .........................................................................................................12
3. Modes de transmission des variables entre module appelant et module appelé.....................12
4. Procédures .....................................................................................................................13
5. Fonctions .......................................................................................................................13

LES BASES DU TURBO-PASCAL............................................................................................. 14

Les différents types ou description de l'encombrement ................................................................14
Les variables............................................................................................................................15
1. Variables de type tableau [array]......................................................................................15
2. Variables de type enregistrement [record].........................................................................15
Les opérateurs .........................................................................................................................16

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 1

 1. Les différents opérateurs .................................................................................................16
2. Priorités des opérateurs...................................................................................................16
Fonctions et procédures standard ..............................................................................................17
1. Syntaxe..........................................................................................................................17
2. Fonctions standard (sauf fichiers et graphisme) .................................................................17
2.1. Fonctions sur les scalaires.........................................................................................18
2.2. Fonctions numériques ..............................................................................................18
2.3. Fonctions sur les chaînes de caractères (= caténiques) ...............................................18
2.4. Divers .....................................................................................................................19
3. Procédures standard (sauf entrées/sorties, fichiers et graphisme) .......................................19
3.1. Procédures traitant les chaînes de caractères .............................................................19
3.2. Procédures diverses .................................................................................................19
3.3. Procédures de contrôle de la console, liées à CRT.......................................................20

LES FICHIERS EN TURBO-PASCAL ......................................................................................... 21

Définition.................................................................................................................................21
1. Les fichiers « text », ou fichiers à accès séquentiels ...........................................................21
2. Les fichiers à accès direct, ou « file of »............................................................................21
Les diverses étapes dans le maniement d’un fichier.....................................................................21
1. Création d’un fichier ou enregistrement d’une nouvelle fiche...............................................21
2. Récupération d’un fichier .................................................................................................22
3. Ecriture en Turbo-Pascal..................................................................................................22
Les modules prédéfinis pour l’utilisation de fichiers......................................................................23
1. Les fonctions ..................................................................................................................23
2. Les procédures ...............................................................................................................24

LE « DEBOGUEUR » DE TURBO-PASCAL OU COMMENT TROUVER LES ERREURS DANS UN PROGRAMME ............ 25

Touche F7, ou RUN → Trace into ..............................................................................................25
Touche F4, ou RUN → Goto cursor ............................................................................................25
Interruptions............................................................................................................................25
Evaluation des variables au cours de l’exécution .........................................................................25

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 2

 Généralités

Objectifs du cours

L’informatique n’est qu’un outil.

La programmation permet de développer l’esprit d’analyse qui est à la base des raisonnements
scientifiques.
Utiliser une documentation : savoir lire et utiliser ce que l’on vous fournit.
Et (pourquoi pas ?) prendre plaisir à réaliser des programmes fonctionnels.

Définition

L’informatique est une discipline qui permet le traitement de l’information à partir de machines
appelées ordinateurs.
Elle permet de traiter des problèmes que l’on sait théoriquement résoudre, mais dont la résolution
serait longue (ou insoluble en raison du temps de calcul nécessaire) sans l’aide d’un ordinateur. Ce
dernier fonctionne avec une relative autonomie si le programme qui lui est fourni est adéquat.

Principales étapes pour concevoir un programme

Pour résoudre un problème, il faut écrire un programme. Les principales étapes de cette conception
sont les suivantes :

Enoncé formel du problème (pensée globale)

R Enoncé verbal approché = « cahier des charges », ou objectifs à atteindre

E Recherche des différentes étapes = analyse descendante

P
Recherche d’algorithmes, ou méthodes de résolution
E
Enoncé formel : métalangage, RAS, GNS = synthèse
T

E Programmation = traduction en langage informatique

R Jeux d’essai

Jusqu’à l’obtention du résultat recherché (programme fonctionnel)

Utilisation du programme (jusqu’à un changement de la problématique)

• Analyser le problème, c’est-à-dire en décortiquer les différentes étapes = analyse descendante.

• Trouver les méthodes de résolution = algorithmes.
• Faire l’analyse détaillée des diverses étapes (GNS : graphes de Nassi-Shneiderman, ou RAS :
représentations algorithmiques structurées) et de leurs relations = analyse ascendante ou
synthèse, grâce au réseau des modules.
• Ecrire le programme et le mettre au point.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 3

Ne pas oublier

• Une bonne interactivité, ce qui rend le programme agréable à utiliser (convivialité).

• Une bonne modularité, ce qui rend le programme plus lisible et facilite les éventuels dépannages.
• Une bonne documentation, ce qui rend le programme évolutif pour son auteur ou d’autres
utilisateurs potentiels (avertis). La documentation est une description succcincte du programme,
grâce à des commentaires inclus dans le code du programme. Elle permet la maintenance du
programme au fur et à mesure de l'évolution des besoins.

Les fautes de programmation

• Les fautes de syntaxe sont signalées à la compilation (ou à l'interprétation pour les langages
interprétés) et se corrigent aisément.
• Les fautes de logique peuvent conduire à des résultats faux et il n'y a aucun remède, sauf un
« débogage » (de l'américain « bug » = cafard) pas à pas.
• Les fautes dans la présentation des données résultent d'une interactivité médiocre qui conduit à
une contradiction entre le programme et les données rentrées. Elles se traduisent par le message
« run time error » au moment de l'exécution d'un programme écrit en Turbo-Pascal (TP), « erreur
d'exécution » en Visual Basic pour applications (VBA).

Règles de savoir-vivre de la programmation structurée

1. On ne programme qu'après avoir fait l'analyse :

• On prévoit les divers modules.
• On dresse la liste des objets (constantes et variables, ou éléments de la boîte à outils VBA) à
utiliser dans chaque module et, éventuellement, on définit de nouveaux types d'objets.

2. Règle de modularité :
• Un programme est un ensemble organisé d'objets possédant des propriétés (et même des
méthodes en VBA), de sous-programmes ou modules (function et procedure ou subroutine).
• Aucun module ne doit dépasser un écran. Eventuellement, au fur et à mesure de l'évolution
d'un programme certains modules seront décomposés en plusieurs modules.

3. Règle de documentation :
• Les identificateurs (noms de modules, de constantes, de variables) doivent être évocateurs.
• Les astuces et les différentes étapes du programme doivent être expliquées, ce qui permet de
relire un programme plusieurs mois après l'avoir écrit, ou d'assurer la maintenance par un
programmeur autre que celui qui a écrit le programme.
• Insertion de commentaire dans le source du programme :
En TP, { } ou (* *) permettent d’insérer des commentaires ;
En VBA, on introduit des lignes de commentaires, en plaçant un ’ en début de ligne.

4. Règle de lisibilité :
La typographie (= indentations) doit faire apparaître la structure logique de chaque module,
notamment les tests et les boucles. Cela permet de trouver plus facilement ses erreurs de
programmation éventuelles.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 4

5. Règle d'interactivité (ou convivialité) :
Le programme doit être utilisable par quelqu'un qui ne connaît pas l'informatique. Cela est possible
par un jeu de questions / réponses entre ordinateur et utilisateur, conçu par le programmeur (write
ou writeln et readln astucieux en TP, ou une interface visuelle constituée notamment de MsgBox et
InputBox en VBA).

6. En Pascal comme en VBA, on écrit en anglais

Et l'ordinateur ne tolère ni les fautes d'orthographe, ni les fautes de ponctuation.

NE PAS OUBLIER :
• Les initialisations des variables.
• Pour la mise au point, chaque module doit être testé indépendamment avant d'être intégré au
programme complet.
• Contrôle et mise au point du programme final sur des données « test ».

En résumé, les diverses étapes de mise au point d’un programme, sont les suivantes :
• Cahier des charges
• Analyse descendante
• Recherche d'un algorithme de résolution
• Synthèse ou analyse ascendante
• En-tête et partie déclarative
• Ecriture du (des) module(s) d’entrée des données
• Ecriture du (des) module(s) de sortie des résultats et de contrôle des données
• Ecriture progressive des autres modules, documentés et lisibles
• Mise au point sur un ou plusieurs jeux d’essais

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 5

 Les ordinateurs

Cette brève description devrait vous permettre d’utiliser mieux l’outil mis à votre disposition, mais est
outrageusement simplifiée.

Anatomie d’un ordinateur

UNITE CENTRALE

ROM Processeur central

Mémoires
=
unité de traitement
←→ secondaires
=
RAM ↔ +
mémoires
séquenceur
de masse

  ↑ ↑
↓ ↓  
Imprimante Ecran Clavier Souris PERIPHERIQUES

• Microprocesseur
• Mémoires : ROM ou mémoire morte
RAM ou mémoire vive
• Bus
• Organes d’entrées / sorties : appartiennent aux organes périphériques

Physiologie d’un ordinateur

• Qu’est-ce qu’un programme ?

En Turbo-Pascal, un programme est du code correspondant à une succession d'ordres ou
instructions généralement effectués séquentiellement, sauf lorsqu'une instruction correspond à une
rupture de séquence ou prise de décision. En VBA, la programmation regroupe à la fois une partie
visuelle (écrans et menus avec lesquels l'utilisateur communique) et une partie de code du langage
VBA qui relie ces éléments visuels et automatis le programme.
• Les diverses traductions nécessaires au déroulement d’un programme
Elles sont nécessaires puisque l'ordinateur ne comprend que le binaire. Nous verrons donc un
exemple permettant de comprendre de manière très simplifiée, comment on passe du programme
en langage informatique (évolué) au code source et réciproquement.
• Les différents niveaux de logiciels

Utilisation de l’ordinateur

Premier exemple de programme en Turbo-Pascal.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 6

 Un système d’exploitation : le MSDOS

Définition

Le système d'exploitation (ou SE) est un programme qui supervise le fonctionnement de l'ordinateur;
il organise notamment la mémoire centrale et gère les communications entre les divers organes de
l'ordinateur. Avec le Turbo-Pascal, nous utilisons le MSDOS pour Microsoft Disk Operating System
(nous verrons quelques éléments de Windows avec le Visual Basic). Au départ ce programme est à un
emplacement convenu du disque. Il est partiellement chargé en mémoire vive (RAM) par ordre du
BIOS (Basic Input Output System) qui réside dans la ROM (mémoire morte) de l'ordinateur.
Contrairement au BIOS, le MSDOS n'est pas lié à l'ordinateur et est évolutif (il existe mais est masqué
sous Windows). Après chargement du tout début du MSDOS en RAM, l'ordinateur sait trouver des
fichiers particuliers : config.sys, command.com, autoexec.bat… C'est alors que l'utilisateur peut
taper une commande ou un nom de fichier en fonction de ses désirs.

Accès au système d’exploitation

A la mise sous tension de l'ordinateur, on provoque le chargement du SE en mémoire vive. Au cours

de cette opération, différents messages s'affichent à l'écran. Puis :
A:\> si le SE est sur disquette,
C:\> si le SE est sur disque dur,
F:\> sur le serveur.
La lettre (A, C ou F) indique quel est le lecteur en service (appelé lecteur courant).
Ces symboles constituent ce que l’on appelle une « invite », et montrent que le SE est prêt à recevoir
des ordres venant de l'opérateur par l'intermédiaire du clavier.
Pour changer de lecteur courant, on tape la lettre représentant ce lecteur suivie de « : », par
exemple : C:\> a:
Lorsque l’on esdt dans l’éditeur/compilateur Turbo-Pascal, on peut le quitter et revenir au SE en
tapant Alt-X, ou en sélectionnant Exit dans le menu File.

Règles relatives aux noms de fichiers

Une bonne partie du travail du SE consiste à manipuler des fichiers. Il faut donc connaître la façon de
les désigner. Le nom complet comporte, dans l'ordre :
la désignation du lecteur à utiliser
le nom du fichier proprement dit (8 caractères au maximum) ou de son chemin d'accès
un point
l'extension (3 caractères maximum)
Par exemple : C:\turbo.cmd
Dans ce nom, « * » peut remplacer une chaîne de caractères quelconque, alors que « ? » peut
remplacer un unique caractère quelconque.
A chaque sauvegarde d’un programme écrit en Turbo-Pascal, l'ancien fichier devient nom.bak et le
fichier sauvegardé est nom.pas.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 7

Principales commandes du système d’exploitation

• DIR donne le catalogue du disque correspondant au lecteur actif. On peut éventuellement préciser
le lecteur demandé (DIR A:) ou un répertoire particulier (DIR A:\DATA).
DIR/W permet un affichage abrégé sur 4 colonnes.
DIR/P permet d’afficher le catalogue écran par écran.

• DEL nomfich enlève le fichier nomfich du catalogue et le fichier devient inaccessible.

• CD nomrep (ou CHDIR nomrep) permet d’accéder au sous-répertoire nomrep, à partir de la
position actuelle.
CD .. permet de « remonter » d’un cran dans l’arborescence du lecteur.
• MD nomrep (ou MKDIR nomrep) permet de créer un nouveau répertoire nomrep.
• RD nomrep efface le répertoire nomrep.
• TYPE nomfich affiche à l'écran (ou imprime si CTRL-P est activé) le contenu du fichier
nomfich.

• FORMAT « formatte » le lecteur actif. Cette opération est nécessaire sur une disquette avant d'y
enregistrer des fichiers. Cela correspond à une préparation de la disquette pour qu'elle soit
compatible avec le système d'exploitation en définissant des secteurs différents. Cette opération
entraîne la perte irrémédiable des fichiers qui étaient sur la disquette.
• COPY A:\fichorigine C:\fichdestination effectue une copie du fichier fichorigine
(modèle, qui était sur le disque A) sur le disque C, en lui attribuant le nom fichdestination.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 8

 Algorithmique, analyse et Turbo-Pascal

Correspondances en Turbo-Pascal et conventions GNS et RAS

Les conventions GNS (Graphes de Nassi-Shneiderman, 1973) ont été étendues sous le nom de RAS
(Représentations Algorithmiques Structurées). Les correspondances vont vous être fournies ici. Un
bloc comprenant plus d’une instruction doit être entouré de begin et end;.

RAS ou GNS Turbo-Pascal

Affectation

identificateur ← valeur identificateur := valeur;

Appel de sous-programme (SP) ou de procédure

 nom du sous-programme(arguments)  nomSP(arguments);

Appel d’une fonction (F)

nom de la fonction(arguments) nomF(arguments);

SI…ALORS…SINON

si <con dition> if <condition>;

then <bloc1>
alors sinon
else <bloc2>;
t t
traitem si condition vraie traitem si condition fausse

Structure CAS

Suivant le cas case <selecteur> of

<val1> : <bloc1>;
S val1
<val2> : <bloc2>;
E
val2 …
L
<valn> : <blocn>;
E … else <bloc>
C
sinon end;
T
E
U
R
ou un autre symbolisme :
Sélecteur
val1 val2 val3

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 9

Boucle indéfinie TANT QUE

TANT QUE <condition> while <condition> do

<bloc>;
instructions de l’itération

Boucle indéfinie REPETER

R repeat
E instructions(s)
P until <condition>;
E instructions de l’itération
T
E
R
jusqu’à <condition>

Boucle définie POUR

Pour variable de contrôle allant de for <v>:=<dep> to <fin> do

<bloc>;
valeur initiale
ou bien
à (pas) instructions de l’itération for <v>:=<dep> downto <fin> do
<bloc>;
valeur finale

Squelette d’un programme

1. Structure

Programme principal
uses nom_des_unités;

Partie déclarative
const … ;
type … ;
var … ;

Modules : procédure(s) ou fonction(s)

Partie exécutive
BEGIN
instruction 1;
instruction 2;
…
instuction n;
END.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 10

2. En Turbo-Pascal

program ……….;
uses <noms unités>;
const ……….;
type ……….;
var objet1 : type1;
objet2, objet3 : type2;
P
A
procedure truc (X : type1 ; Y : type2); X et Y sont des arguments formels R
T
const ……….;
I
type ……….;
E
var ……….; variables locales de la procédure
Begin
D
instruction 1;
E
…
C
instruction n;
L
End; A
R
A
function machin (Z : type1) : type2; Z est un argument formel
T
la fonction est de type2
const ……….; I
type ……….; V
var ……….; variables locales de la fonction E
Begin
instruction 1;
…
instruction n;
End;

BEGIN
E
……….; P X
A E
truc(objet1, objet2);
R C
……….; T U
I T
objet3 := machin(objet1);
E I
………. ; V
E
END.

Les modules

1. Définition
Un programme est un ensemble de modules liés entre eux par une ou plusieurs relation(s) d’appel.
Chacun a la même structure : en-tête, partie déclarative, partie exécutive. Un programme permet
ainsi l’exécution automatisée d’une tâche complexe.
Par commodité, nous fixons les règles suivantes :
• les programmes seront écrits en minuscules,

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 11

 • sauf les éléments suivants :
BEGIN
END. qui entourent la partie exécutive du programme principal,
et
Begin
End; qui entourent la partie exécutive des divers modules.
Chaque module représente une action composée. Il comprend, outre l’en-tête (programme principal)
ou l’interface (procédures et fonctions), deux parties essentielles :
• la partie déclarative ou description des objets du module,
• la partie exécutive ou description des actions élémentaires.

2. Réseau de modules
Il existe un module principal unique ou programme principal (PP). C’est par lui que commence
l’exécution du programme et c’est lui qui permet l’établissement des liens logiques (conçus par le
programmeur) entre les divers modules. En effet, un module peut employer d’autres modules
spécialisés dans des sous-tâches particulières. Pour décrire ces relations, on utilise le réseau des
modules.
PP

↓
 ↓
↓ intervalle_de_confiance
entre 
↓
↓ ↓
moyenne variance
Nous venons de l’illustrer pour un programme qui permettrait de calculer l’intervalle de confiance de la
moyenne d’un échantillonnage ; les valeurs seraient connues grâce au module entre (ce dernier
module peut correspondre aussi bien à une saisie au clavier qu’à la lecture d’un fichier préexistant).
Le PP appelle deux module entre et intervalle_de_confiance ;ce dernier appelle lui-même deux autres
modules moyenne et variance.

3. Modes de transmission des variables entre module appelant et module appelé

Le PP sera toujours un module appelant. Les fonctions sont des modules qui n’ont qu’une et une seule
valeur de sortie. Ensuite, il faut se poser deux questions successives pour comprendre les
transmissions.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 12

4. Procédures

QUESTION 1 La variable X transmise a-t-elle un contenu lors de l’appel du module ?


↓ ↓
OUI NON
↓ ↓
QUESTION 2 Est-elle modifiée par la procédure ? Est-elle réutilisée après ?
 
↓ ↓ ↓
NON OUI OUI

RAS IN IN/EX EX

Argument - valeur Argument - adresse

Pascal procedure truc(X : integer); procedure truc(var X : integer);

IN correspond à la consultation de données, IN/EX à leur modification, alors que EX est une
création de variables.

5. Fonctions
La convention est un peu différente pour les fonctions (une seule valeur de sortie définie par la
fonction, dont il faut aussi définir le type, le type de la fonction). Soit une fonction de nom chose.

chose de type…

IN liste des arguments

variables locales

partie exécutive

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 13

 Les bases du Turbo-Pascal

Les différents types ou description de l'encombrement

Type de variables Encombrement (octets) scalaire I/O prédéfini

- (entrée)
Logique [boolean] 1 + +
+ (sortie)
Entiers# : + + +
Octet [byte] 1 + + +
Entier [integer] 2 + + +
#
Réels : - + +
Réel [real] 6 - + +
Caractère [char] 1 + + +
n+1 pour n caractères
Chaîne [string] - + +/-
(n ≤ 255)
Tableau [array] - élément par élément -
Enuméré + - -
variable selon les choix
Ensemble [set of] - - -
du programmeur
Intervalle + - -
Enregistrement [record] - élément par élément -
Fichiers:
variable selon les choix
[text] - élément par élément -
du programmeur
[file of] - élément par élément -
#
voir le tableau ci-dessous :

Chiffres
Type significatifs Intervalle de définition Octets
Entiers byte 0 ≤ X ≤ 255 1
shortint -128 ≤ X ≤ 127 1
integer -32 768 ≤ X ≤ 32 767 2
tous
word 0 ≤ X ≤ 65 535 2
longint -2 147 483 648 ≤ X ≤ 2 147 483 647 4
18
comp* |X| ≤ 9,2 . 10 8
-39 38
Réels real 11-12 2,9 . 10 ≤ |X| ≤ 1,7 . 10 6
single@ 7-8 1,5 . 10-45≤ |X| ≤ 3,4 . 1038 4
double@ 15-16 5,0 . 10-324≤ |X| ≤ 1,7 . 10308 8
@ -4951 4932
extended 19-20 1,9 . 10 ≤ |X| ≤ 1,1 . 10 10
@
types nécessitant un coprocesseur arithmétique.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 14

Les variables

Ce sont les informations traitées par le programme. Elles occupent une certaine place en mémoire (ou
encombrement) qui leur est affectée au moment où on définit leur nom en leur attribuant un type.
Chacune correspond à une adresse en RAM. Leur contenu est défini par affectation, par saisie ou
transfert de données, ou par calcul.
Deux types de variables un peu plus délicates à manier vont être décrits plus en détail. Le mieux est
de commenter un extrait de programme dans chaque cas.

1. Variables de type tableau [array]

Il faut, dans la partie déclarative (PD), déclarer la taille et le type des éléments du tableau, puis
réserver une place en mémoire (var). Ensuite, dans la partie exécutive (PE), on peut avoir accès à
chaque élément du tableau, désigné par « nom du tableau[place] ».

type seqprot = array[1..1000] of char;

{au + 1000 AA dans le code à une lettre}
var longueur, i : integer; PD
proteine : seqprot;
{réservation de la place mémoire pour le tableau proteine}

BEGIN
{remplissage du contenu des variables longueur et proteine}
for i := 1 to longueur do
write(proteine[i]);
{affichage de la protéine en code à une lettre} PE
{proteine[i] permet d'avoir accès à chaque case du tableau}
writeln;
END.

2. Variables de type enregistrement [record]

Ce type permet de dresser des tableaux utilisant plusieurs types informatiques. Il faut donc, dans la
partie déclarative, déclarer le type de chacun des champs de l'enregistrement puis réserver une place
en mémoire (var). Ensuite, dans la partie exécutive, il y a deux manières d'avoir accès à chacun des
champs. En effet, l'instruction with permet de créer un environnement temporaire évitant la
répétition du nom de la variable enregistrement (obs ici) lorsqu'on travaille sur différents champs de
cette variable.
Type observation = record
secteur : string[10];
espece : string[25];
date : string[10]; PD
nombre : integer;
end;
Var obs : observation;

BEGIN BEGIN
{remplissage de la var. obs} {remplissage de la var. obs}
writeln(obs.secteur); with obs do
writeln(obs.espece); begin
writeln(obs.date); writeln(secteur);
writeln(obs.nombre); PE1 writeln(espece); PE2
END. writeln(date);
writeln(nombre);
end;
END.

Deux manières d'obtenir l'affichage du contenu de la variable obs

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 15

On peut représenter en RAS l'instruction with et les instructions qu'elle concerne, ainsi :

Avec obs
Afficher (secteur)
Afficher (espece)
Afficher (date)
Afficher (nombre)

Les opérateurs

1. Les différents opérateurs

Opérateurs Types des opérandes Symbole Signification

Arithmétiques valeurs numériques - changement de signe et soustraction
+ addition
* multiplication
/ division
Arithmétiques valeurs entières div quotient entier de la division
mod reste entier (= modulo)
shl décalage à gauche = multiplication par 2a
shr décalage à droite = division par 2a
Relationnels valeurs numériques, =
valeurs booléennnes,
<
caractères ou chaînes
>
<> différent de
<= inférieur ou égal
>= supérieur ou égal
Logiques valeurs booléennes or ou
valeurs entières
xor ou exclusif
and et
not complémentaire, contraire
Texte chaînes de caractères + concaténation = fusion
Ensembles ensembles + union
* intersection
- différence ou complément

2. Priorités des opérateurs

Il existe 5 catégories d’opérateurs. Lorsque plusieurs opérateurs figurent dans la même expression, ils
ne sont pas traités dans le même ordre; certains sont évalués avant les autres car ils ont une priorité
plus élevée. Voici les opérateurs classés par priorité décroissante :

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 16

 1) - changement de signe
2) not
3) Opérateurs de multiplication : *
/
div
mod
and
shl
shr
4) Opérateurs d’addition : +
-
or
xor
5) Opérateurs relationnels : =
<>
<
>
<=
>=
in
Les opérateurs d’une même catégorie ont la même priorité. Lorsque plusieurs opérateurs de même
priorité se trouvent dans une même expression, l’évaluation se fait de gauche à droite. Les
expressions placées entre parenthèses sont évaluées avant les autres et lorsqu’il y a plusieurs
parenthèses ce sont les parenthèses les plus internes qui sont évaluées en premier.
Par exemple : A * (B - C) / B / A vaudra (B – C) / B
2 1 3 4 ⇐ ordre d’évaluation
En effet, la parenthèse est évaluée en premier. Ensuite, les autres opérateurs ayant la même priorité
seront effectués dans leur ordre d’apparition de gauche à droite. L’ordinateur simplifiera par A.

Fonctions et procédures standard

1. Syntaxe
Identificateur(liste de paramètres)
L’identificateur désigne la fonction ou la procédure. La liste des paramètre, si elle existe, est
constituée d’une ou plusieurs constantes, variables ou expressions, séparées par des virgules.

2. Fonctions standard (sauf fichiers et graphisme)

Les arguments des fonctions doivent avoir une valeur avant l’appel de la fonction.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 17

2.1. Fonctions sur les scalaires

Fonction Type des arguments Type du résultat Nature du résultat

odd(x) entier booléen vrai si x impair, faux si x pair
ord(x) tout type scalaire octet ou entier rang (valeur ordinale parmi les valeurs
du même type
pred(x) tout type scalaire = type argument prédécesseur de x s’il existe
succ(x) tout type scalaire = type argument successeur de x s’il existe

2.2. Fonctions numériques

Ce sont les fonctions élémentaires qui interviennent dans les calculs et l’argument éventuel s’appelle x
dans le tableau suivant.

Fonction Type des arguments Type du résultat Nature du résultat

abs(x) entier ou réel = type argument valeur absolue de x
arctan(x) entier ou réel réel (radians) angle dont la tangente = x (radians)
cos(x) entier ou réel réel cosinus de x (angle en radians)
exp(x) entier ou réel réel exponentielle de x
frac(x) réel réel partie décimale de x ; frac(2.3 = 0.3
int(x) réel réel partie entière de x (en réel)
ln(x) entier ou réel > 0 réel logarithme népérien de x
random aucun argument réel nombre aléatoire ∈ [0,1[
random(x) entier entier nombre aléatoire ∈ [0,x[
round(x) réel entier entier le plus proche de x
sin(x) entier ou réel réel sinus de x (angle en radians)
sizeof(x) x=variable ou type entier nombre d’octets occupés par x
sqr(x) entier ou réel = type argument carré de x
sqrt(x) entier ou réel réel racine carrée de x
trunc(x) réel entier partie entière de x (en entier)

2.3. Fonctions sur les chaînes de caractères (= caténiques)

Ces fonctions servent à traiter les chaînes de caractères, qui ne doivent pas dépasser la taille spécifiée
dans les déclarations et en aucun cas 255 caractères.

Fonction Type des arguments Type du résultat Nature du résultat

chr(x) octet caractère caractère ASCII dont le code est x
copy(ch,p,x) ch : chaîne chaîne sous-chaîne de x caractères, à partir
p,x : octet du pième caractère de la chaîne ch
concat(ch1,…,chn) chaînes chaîne fusion (concaténation) des chaînes
(résultat ≤ 255 caractères)
length(ch) chaîne octet nombre de caractères dans la chaîne
pos(ch1,ch) chaînes octet rang dans la chaîne ch du 1er
caractère de la sous-chaîne ch1
présente dans la chaîne ch

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 18

ord(car) caractère octet code ASCII du caractère
upcase(car) caractère caractère minuscules ⇒ majuscules

2.4. Divers

Fonction Type du résultat Nature du résultat

ioresult entier zéro si les entrées/sorties sont correctes dans la zone où la
directive de compilation de contrôle des entrées/sorties est
inactivée. un code d’erreur dans les autres cas
keypressed booléen vrai si une touche est frappée au clavier
readkey caractère enregistrement du caractère frappé au clavier (tampon)
wherex numéro ∈ [1,80] position horizontale du curseur
wherey numéro ∈ [1,25] position verticale du curseur

Les fonctions keypressed et readkey sont liées à la bibliothèque d’outils CRT.

3. Procédures standard (sauf entrées/sorties, fichiers et graphisme)

3.1. Procédures traitant les chaînes de caractères

Procédure Type des arguments Nature du résultat

delete(ch,p,x); ch : chaîne supprime x caractères dans la chaîne ch, à partir de la
p,x : octets position p
insert(ch1,ch,p); ch1, ch : chaînes insère la sous-chaîne ch1 dans la chaîne ch, à partir de la
p : octet position p
str(x,ch); ch : chaîne convertit le nombre x (∀ type) en chaîne de caractères
x : nombre
val(ch,x,code); ch : chaîne convertit la chaîne de caractères ch en un nombre entier
x : nombre ou réel x (selon le type de x)
code : entier #
#
S’il ne se produit aucune erreur dans la conversion le code prend la valeur 0, sinon il prend la
valeur de la position du premier caractère erroné et x est indéfini. Les espaces placés avant ou
après la valeur numérique ne sont pas autorisés et devront donc être supprimés avant d’utiliser
cette procédure.
3.2. Procédures diverses

Procédure Type des arguments Nature du résultat

inc(i,p); i,p: entiers i prend la valeur i + p, ou i + 1 si p est omis
dec(i,p); i,p: entiers i prend la valeur i – p, ou i - 1 si p est omis
fillchar(V,N,x); N : entier remplit la variable V avec N octets (ou caractères) x tous
V : quelconque identiques
x : octet, caractère
halt; aucun argument interrompt l’exécution du programme
exit; aucun argument permet de sortir d’un sous-programme avant la fin et
ramène au module appelant
randomize; aucun argument initialise le générateur de nombres aléatoires avec une
valeur non contrôlable par l’utilisateur

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 19

3.3. Procédures de contrôle de la console, liées à CRT
L’écran comporte 80 positions en largeur et 24 en hauteur, avec l’origine en haut et à gauche. L’axe
des y est donc inversé par rapport à nos conventions habituelles.

Procédure Type des arguments Nature du résultat

clreol; aucun argument efface tous les caractères situés après le curseur sur la
ligne, sans déplacer ce dernier
clrscr; aucun argument efface l’écran, curseur dans le coin supérieur gauche
delay(x); x : entier provoque une attente d’exécution (maxi x millisecondes)
delline; aucun argument détruit la ligne située au niveau du curseur en faisant
remonter les lignes suivantes d’un cran
gotoxy(a,b) a,b : entiers positionne le curseur à la colonne a et à la ligne b,
l’origine étant le coin supérieur gauche (1,1)
insline; aucun argument insère une ligne blanche au niveau du curseur en
descendant les lignes suivantes d’un cran.
textcolor(x); x : entier définit la couleur d’affichage des caractères, x ∈ [0,15]
textcolor(x+blink); x : entier clignotement du texte affiché dans la couleur x
textbackground(x); x : entier définit la couleur du fond du texte, x ∈ [0,7]

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 20

 Les fichiers en Turbo-Pascal

Définition

Les fichiers informatiques permettent de stocker (enregistrer) des informations sur une mémoire
distincte de la mémoire centrale ou mémoire vive (RAM), c’est-à-dire sur un disque (support
physique). Ceci évite de devoir refaire une saisie à chaque exécution (RUN). Ces informations
peuvent être consultées (lues), modifiées, stockées (enregistrées) à la demande.
Nous étudierons deux types de fichiers :

1. Les fichiers « text », ou fichiers à accès séquentiels

Dans ces fichiers, les fiches sont de différentes longueurs. La fin d’une fiche est indiquée par un
retour chariot. Ils sont universels (code ASCII) et peuvent être créés de diverses manières (par
programme, sous l’éditeur du Turbo Pascal, sous l’éditeur du DOS). Leur accès est uniquement
séquentiel et ils sont délicats à utiliser lorsqu’il existe plusieurs données sur une même fiche. Par
contre, comme ils sont universels, ils peuvent être utilisés sous d'autres applications que le Turbo
Pascal, et sous un environnement non DOS, par exemple par Excel sous Windows.

2. Les fichiers à accès direct, ou « file of »

Dans ces fichiers, les fiches sont toutes de même longueur. Ils ne peuvent être créés que par
programme. On peut atteindre une fiche par accès direct (ceci permet d’avoir accès à une fiche au
milieu du fichier et notamment de la modifier aisément) ou séquentiellement. Ils sont liés à la
technologie de la machine.

Les diverses étapes dans le maniement d’un fichier

1. Création d’un fichier ou enregistrement d’une nouvelle fiche

Programmeur =

Programme ou

Unité Centrale de l’ordinateur

disquette
1
fiche
3
Autre 2
utilisateur fichier

2bis calcul

1. message d’explication (= interactivité) 2. entrée de données : lecture au clavier

2bis. transfert d’un calcul dans une fiche 3. écriture (enregistrement) dans un fichier
En somme, il y a trois étapes successives pour enregistrer une nouvelle fiche :
• message à l’utilisateur
• saisie des données ou calcul de résultats à enregistrer
• stockage de ces valeurs

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 21

2. Récupération d’un fichier

Programmeur =

Programm

Unité Centrale de l’ordinateur

disquette
fiche
1
Autre 2
utilisateur fichier

2bis calcul

1. récupération d’un fichier (fiche par fiche) 2. résultats : affichage à l’écran ou impression
2bis. utilisation du fichier pour de nouveaux calculs
En somme, il y a deux étapes successives pour la récupération de données sur un fichier :
• récupération du contenu d’une fiche
• affichage à l’écran ou impression avec des explications pour l’utilisateur, ou utilisation pour de
nouveaux calculs

3. Ecriture en Turbo-Pascal

Le maniement des fichiers exige systématiquement au moins 5 instructions dans un programme écrit
en Turbo Pascal.
• pour enregistrer une fiche,
• pour consulter une fiche,
• pour modifier une fiche.
La variable fichier, qui correspond à une mémoire-tampon de l'ordinateur au moment de l'exécution,
est définie dans la partie déclarative. C'est une variable abstraite qui va servir à la manipulation du
fichier et n'existera plus après exécution. Elle est associée au nom concret du fichier (nom sur le
disque qui persiste après exécution) grâce au couplage qui appartient à la partie exécutive du
programme. Les tableaux suivant résument l’utilisation de ces 5 instructions dans tous les cas de
figure : fichiers des deux types utilisés en création, modification ou récupération.

Fichiers « TEXT »
ECRITURE = STOCKAGE = ENREGISTREMENT LECTURE = CONSULTATION = RECUPERATION

1 Déclaration : var ...... : text;

Partie exécutive

2 Couplage : assign(...); Couplage : assign(...);

3 Création : rewrite(...); reset(...);

Ajout : reset(...); et append(...);

3bis Saisie, assignation ou calcul du contenu

d’une fiche

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 22

4 Enregistrement : writeln(...); Consultation : readln(...);

4bis Affichage, impression ou tuilisation pour

des calculs de la fiche obtenue en 4

5 Fermeture : close(...); Fermeture : close(...);

Fichiers « FILE OF »
ECRITURE = STOCKAGE = ENREGISTREMENT LECTURE = CONSULTATION = RECUPERATION

1 Déclaration : type fiche = Déclaration : type fiche =

fichier = file of fiche; fichier = file of fiche;
var fic : fiche; var fic : fiche;
f : fichier; f : fichier;

Partie exécutive

2 Couplage : assign(...); Couplage : assign(...);

3 Création : rewrite(...); reset(...);

Modification : reset(...); et seek();

3bis Saisie, assignation ou calcul du contenu

d’une fiche

4 Enregistrement : write(...); Consultation : read(...);

4bis Affichage, impression ou tuilisation pour

des calculs de la fiche obtenue en 4

5 Fermeture : close(...); Fermeture : close(...);

Les modules prédéfinis pour l’utilisation de fichiers

On appellera f les fichiers au cours de ce paragraphe.

1. Les fonctions

Fonction Type des arguments Type du résultat Nature du résultat

ioresult aucun argument entier zéro si les E/S sont correctes entre
{$I-} et {$I+}.
eof(f) fichier text ou file of logique false tant que la fin du fichier n’est
pas atteinte
eoln(f) fichier text logique indique les fins de ligne (délimitation
des fiches) du fichier text f
filesize(f) fichier file of longint taille du fichier
filepos(f) fichier file of longint position du pointeur de fiches

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 23

2. Les procédures

Procédure Type des arguments Nature du résultat

assign(f,nom_f); f : text ou file of Couplage du tampon f (de type fichier) avec le fichier
nom_f : chaîne dont le nom sur le disque est nom_f
rewrite(f); fichier text ou file of Ouverture du fichier f, à créer
reset(f); fichier text ou file of Ouverture du fichier f déjà existant
write(f,x); f : fichier file of Enregistrement de la fiche x sur le fichier f
x : type fiche
read(f,x); f : fichier file of Récupération de la fiche x sur le fichier f
x : fiche
writeln(f,x1,x2…); f : fichier text Enregistrement de x1,x2… sur le fichier f
x1,x2… : fiches
readln(f,x1,x2…); f : fichier text Récupération de x1,x2… sur le fichier f
x1,x2… : fiches
append(f); fichier text Permet d’agrandir un fichier par ajout en fin de fichier
seek(f,n); f : fichier file of Positionne le pointeur de fiche du fichier en n+1 (la
n : entier première fiche a le pointeur 0)
close(f); fichier text ou file of Fermeture du fichier f
erase(f); fichier text ou file of Effacement du fichier f qui doit être fermé auparavant
rename(f,nom2); f : text ou file of Change le nom du fichier couplé à f sur le disque, le
nom2 : chaîne nouveau nom étant nom2

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 24

 Le « débogueur » de Turbo-Pascal
ou comment trouver les erreurs dans un programme

Cet outil est intéressant lorsqu’il n’existe plus de fautes de syntaxe (détectées à la compilation), et
que néanmoins à l’exécution (RUN), on n’obtient pas ce que l’on attendait.

Touche F7, ou RUN → Trace into

La commande F7 exécute le programme ligne à ligne, car, pour le débogueur, l’unité est la ligne de
programme.
• Si plusieurs instructions sont écrites sur la même ligne, elles sont exécutées par le même F7.
Par contre, une instruction à cheval sur plusieurs lignes est traitée d’un bloc.
• Les instructions begin et end sont considérées comme exécutables, mais non repeat.
• Les lignes qui ne comportent pas d’instruction exécutable ne sont pas prises en compte.
Après chaque exécution d’une ligne, il y a arrêt et retour au mode éditeur, avec surbrillance sur la
prochaine ligne à exécuter, le curseur pouvant être à nouveau déplacé à volonté. En répétant la
frappe de la touche F7, on progresse de ligne en ligne avec, en cas d’appel d’une procédure ou d’une
fonction, passage à la première ligne de ce module. La frappe répétée de F7 permettra de parcourir
tout le sous-programme avant de retourner au module appelant. On peut éviter ces entrées dans les
sous-programmes, si on le désire, en tapant F7, ou RUN → Step over à la place de F7. Le sous-
programme est alors entièrement exécuté comme une seule instruction, et on passe à la ligne suivant
l’appel de ce module dans le module appelant.

Touche F4, ou RUN → Goto cursor

Cette commande est à utiliser afin d’interrompre moins souvent le programme pour exécuter d’un seul
coup des parties qui ne posent pas de problème. C’est très utile pour examiner les boucles.
L’exécution s’arrêtera à la ligne où est placé le curseur.

Interruptions

A tout instant, on peut lancer l’exécution par Ctrl+F9 ou RUN → Run à partir de l’endroit où l’on
s’est arrêté jusqu’à la fin du programme.
On peut aussi cesser le débogage et revenir à la situation suivant la compilation par Ctrl+F2 ou
RUN → Program reset.

Evaluation des variables au cours de l’exécution

On peut consulter les valeurs de toutes les variables connues (locales ou globales au module dans
lequel on se trouve) à chaque interruption grâce à la commande Ctrl+F4 ou
Debug → Evaluate/Modify. Elle permet à la fois d’afficher la valeur prise par une variable et, ce qui
est beaucoup moins intéressant, de modifier cette valeur.
La commande Ctrl+F4 affiche une boîte de dialogue avec trois lignes de saisie (« Expression »,
« Result », « New value ») et quatre boutons (« Evaluate », « Modify », « Cancel », « Help »).
L’utilisateur, en général, écrit sur la première ligne une expression, le plus souvent un nom de
variable. La valeur s’écrit sur la deuxième ligne lorsque l’utilisateur appuie (grâce à la souris) sur le
bouton « Evaluate ». On peut aussi vérifier les valeurs des différentes cases d’un tableau, celui-ci
étant parcouru à l’aide des flèches. Lorsque le tableau est trop vaste, on peut n’en afficher qu’une
partie en précisant l’élément, la ligne (premier indice) ou les répétitions: par exemple pour un tableau

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 25

T[1..6,1..10] qui comprend 60 éléments, T[1] affichera les 6 éléments de la première ligne, T[1],2 les
12 éléments des deux premières lignes, T[1,3],2 les éléments T[1,3] et T[1,4]. Les éléments affichés
sont séparés par des virgules.
On peut évaluer plusieurs expressions successivement. On peut les reparcourir avec les flèches car la
boîte contient une liste historique conservée entre deux Ctrl+F4. Il est donc facile de contrôler les
valeurs de plusieurs variables en divers point du programme après des modifications apportées au
programme. On revient à l’éditeur en appuyant sur la touche ESC, ou en fermant la boîte de dialogue.
Néanmoins, l'utilisation du « déboggeur » est souvent fastidieuse. Rien ne vaut une mise au point pas
à pas après une analyse rigoureuse.

Méthodes de Modélisation et de Bioinformatique Cours Turbo Pascal 26