Thé orie Progra

Variables :
Il existe différents types de variables : integer (chiffres entiers), real(les réels), char(les
caractères) et string(les chaines de caractères). Les variables sont déclarées avant le
programme en tant que tel.

Interaction : il y a des restrictions de types entre variables (exemple : on ne peut

rentrer une variable integer dans une variable char).string<=char, real<=integer.Ces liaison
sont à sens uniques !!!

Déclaration : maVariable, madeusièmevariables, MATROISIEMEVARIABLE : integer

(NB : le type de variable) ; autres déclarations de variables séparées par des ‘’;’’…

Tableaux :
Un tableau est un ensemble de variables qui ont des adresses qui se suivent (la
première adresse est 1200 et la suivante 1201 p.e.). Ils peuvent avoir plusieurs dimension par
exemple pour un tableau à 2 dimension, voyez ca comme une grille.

TOUTES LES RÈGLES DES VARIABLES S’Y APPLIQUENT DONC.

Voici un exemple de déclaration de tableaux à une ou plusieurs dimensions :

Var t1  :array[1..100,10..20] of array[10..12] of integer ;t2:array[10..20] of integer;

Le t1 est un tableau à 3 dimension, il existe deux manières de déclarer une nouvelle

dimension, soit la plus courte voir le premier array, soit la seconde dans le deuxième array
après le of il est obligatoire de mettre un type de variables après un dernier of. Le t2 est un
tableau d’integer à 1seul dimension.

Préprocesseur :
C’est la où on déclare les variables, on donne un nom au programme,…
Il existe encore deux élément à aborder :
-les constantes (écrit const) une suite de caractères qui, quand ils seront lus à la compilation,
seront remplacez par la valeur de la constante ou de la suite de caractère qui s’y trouve.
Déclaré : const maconst=’4’ ;

-les types dans le même genre que la constante sauf qu’ils s’appliquent uniquement aux
variables et sont utilisés comme integer, char,…
Fonctions simples :
(Saisir)Read et readln suivit d’une ou plusieurs variables séparées par des « , » ; Il est
fortement conseillé d’utilisé exclusivement le readln pour une saisie clavier car le read sert à
prendre des données de manières composées !!!

(Afficher)Write et writeln  suivit d’un texte entre parenthèse et ‘ en début et en fin,

voici un exemple d’utilisation de write avec une variable :

Writeln (‘Un texte don la variable ‘’c’’ vaut ‘, c,’.’)  ;

Comme pour le readln, le ln signifie « à la ligne ». Pour mettre des éléments entres
guillemets, il faut écrire des doubles guillemets. Astuce avec les write : après une variable, on
peut écrire « : » suivit d’un chiffre Pour tout types variables, si le chiffre est positif, on fait un
décompte des caractères de la droite vers la gauche ; si le chiffre est négatif, on décompte de
la gauche vers la droite ; si la différence du nombre noté et des caractères qui composent la
variable est négative, les caractères supplémentaires (de gauche si +, de droite si - ) ne seront
pas affichez.

Structures :
-opérants :
Avant de parler de structure, il vous faut connaître les 3 opérants des conditions :
AND, OR, NOT (cond). Le AND et le OR sont des mots liens entre condition. !! Faites
toujours attention au sens de ce que vous écrivez quand vous utilisez les opérants, ils peuvent
vous piéger facilement.

-conditionnelles :
Le « if then else » voici un exemple type que je vais expliquer :

If (c<x) then
begin
writeln (‘’’c’’ est plus petit que ‘’x’’.’);
c  :=x;
end
else
begin
x  :=c
end;

Explication : on met la condition du if (si) entre parenthèse (si opérants) suivit d’un then. Le
begin et le end du if permettent d’écrire une suite d’instruction ; si on n’a qu’une seul
instruction ou même aucune, il n’est pas obligatoire d’écrire le begin et le end dans le if
uniquement ! Si on ne doit rien mettre dans le else alors le begin et end deviennent obligatoire
et on doit mettre un end ; à la place du end ce qui permet de ne pas écrire la partie else.
 Le « case of » que nous n’avons pas vu au cours mais qui comporte ces avantages.
Imaginez un cas ou vous avez 100 possibilités avec la même variable et que vous devez toutes
les écrire, avec le if ce serait un travail fastidieux, mais pas avec le case of.

Voici un example:

case operator of
'*’: result:= number1 * number2;
'/': result:= number1 / number2;
'+': result:= number1 + number2;
'-': result:= number1 - number2;
otherwise invalid_operator := 1
end;
Le nom de la variable est mi entre le case et le of. Ensuite on énumère les possibilités suivies
de ‘’ :’’ et de l’action à faire dans ce cas. Naturellement s’il y en a plusieurs, il faut rajouter
un begin et un end  ;.

- boucles :
Le while (cond) do (pendant que … faire) emploie du même style que le if sauf qu’il
effectue une boucle. Dans les exercices machines, essayez de faire les invariants.

Record :
Le record permet d’ajouter des attributs à une ou plusieurs variables en passant par
un nouveau type de variable. Voici un exemple :
TYPE studentname = packed array[1..20] of char;
studentinfo = RECORD
name : studentname;
mark : integer
END;
Tstudent = array [1..20] of studentinfo;
VAR student1 : studentinfo; tabstudent : Tstudent
…student1.name :=’Julien’  ;
Il est important de mettre les records dans les types surtout en cas d’utilisation de procédures
ou de fonctions. Pour accéder à un attribut, il suffit d’écrire variable.attribut Logiquement on
peut créer des tableaux (voir exemple) en créant un type avec le array (c’est très important)
dont l’écriture devient tableau[n°].attribut

File :
A comparé aux tableaux, ils permettent de garder des informations même après la
fermeture du programme. Ils comportent un point négatif, on ne peut choisir où on veut aller
dans le fichier, on ne peut que avancer.
-variable : f :file of type
-déclaration : il faut premièrement rattacher la variable de la mémoire vide au nom du fichier
externe : string  :=’C:/User/mon_fichier.ext’ ; assigne(f ,string) ; ou assign(f,
‘mon_fichier.ext’) ;
-test :dans un cas d’utilisation de lecture, il faut toujours tester le caractère pour voir si on est
à la fin du fichier avec eof(f) si vous lisez la fin du fichier, le programme plantera !
-utilisation : Elle se fait en 2 temps (un peu comme le randomize), on dit au compilateur, je
vais utiliser le fichier de cette manière (le but est de mettre la pointe de lecture au bon endroit)
et ensuite utiliser le fichier !!!!!Quand on lis ou on écrit dans un fichier, la tête de lecture
avance toute seul !!!!! voici les 2 méthodes d’utilisation :
reset(f) rewrite(f)
read(f,e) write(f,e)

On lit le fichier, la tête de lecture se met au début | On écrit dans le fichier, le contenu du
fichier
du fichier on enregistre la valeur dans la variable e | est supprimé, la tête de lecture se met à la
fin
, du même type que la variable fichier | de celui-ci, on écrit la valeur de la
variable
| (de même type que la variable fichier)

On ne peut lire et écrire à la fois dans un même fichier !!!

-fermeture :Pour libérer l’espace ou pouvoir réutiliser celui d’un variable file, on ferme le
fichier, il est conseiller d’ouvrir et fermer les fichier dans un même morceau de programme
(dans la partie main et les procédures). Pour les procédure, cela allège la gestion de la
mémoire. On effectue cette opération : close(f)

Text : type de fichier particulier

Déclaration : var f  :text ;
le type text est un correspondant de file of char + une gestion des lignes et des types.

ATTENTION : n’oubliez pas d’indiquer le mode d’utilisation (reset ou rewrite) !!!

Gestion des lignes

Readln(f,c  ) ; : lire dans le fichier f, envoyer la lecture dans la variable c et aller à la ligne
read(f,c) ;readln(f)  ;
Le fichier par défaut du read est le clavier.
=> read(c)  ; : lire du clavier(un fichier text) et enregistrer la lecture dans la variable c

Writeln(f,c)  ; :écrire dans le fichier f la variable c et aller à la ligne

write(f,c) ; writeln(f) ;
le fichier par défaut du write est l’écran. (conséquence similaire que pour le clavier)

Eoln(f) ; :bouléen du même genre que eof sauf qu’il est pour la ligne (eoln : end of line)

Gestion des types

Un grand avantage des fichiers text est que vous pouvez récupérer le contenu du fichier avec
des variables de n’importe quel type (en effet une variable (fichier) de type text est un fichier
et pas une variable commune !). Dans l’assignation de la valeur, le processeur avancera dans
le fichier tant que le caractère est un caractère appartenant au type de la variable

Exemple : si c :integer contenu du fichier 123,4 => c =123 et le pointeur est sur la virgule. En
effet la virgule n’est pas un caractère valide pour le type integer.

Conseil
Il est conseillé d’écrire dans le fichier avec des writeln pour avoir une séparation entre les
éléments puisqu’un eoln n’est un caractère valide pour aucun type en pascal. De plus dans le
cas d’un string ou d’un tableau de char, la boucle sera à effectuer =>eoln=true facilitant ainsi
l’écriture de la boucle.

Fautes courantes :
Structure du programme :
Un programme pascal commence par son nom : program nom ;
suivit des constantes : const NOMCONST1=150 ;
et des types : type nomType1=array [1..NOMCONST1] of integer ;
ainsi que des variables : var mavariable : nomType1 ;
suivit des éventuelles procédures qui n’utilisent que des types globales (on ne pourra écrire
array [1..2] of nomType1, il faudra d’abord créer un type pour être compilable !) :
procedure nomprocedure (i :integer ; tab : nomType1) ;
begin
…
end ;
ainsi que d’éventuelles fonctions : (n’oubliez pas, les fonctions ne font que retourner des
valeurs, pour le reste il existe les procédures)
function variableretourner(compteur :integer) :real ;
begin
…
end ;
begin
…(le programme en soit)
…
end.

Remarque : les ‘ ;’ ne servent qu’à dire au processeur qu’il y a une instruction qui suit !

Boucles :

Compteur :
Il y a 2 manières d’utiliser un compteur, soit en l’égalant à ‘la borne inférieur du
tableau’ on incrémente le compteur à la fin de la boucle avec la condition : cpt<=Borne
Supérieur, soit en l’égalant à ‘la borne inférieur du tableau’-1 alors, on incrémente au début de
la boucle et la condition : cpt<BS. Il ne faut pas inverser ces 2 méthodes
N.B : ces deux méthodes sont aussi bonnes l’une que l’autre, il s’agit d’utiliser la bonne dans
les bons cas.

Boucle ne signifie pas compteur !!! (exemple lecture de fichier)

Condition :
Pour boucler tant que deux condition ne sont pas remplies on lie avec AND et non OR
en opposition au if then else ou au case of