PROGRAMMATION STRUCTUREE : LE PASCAL

Ce petit tutorial (ou aide mémoire:) a été créer dans le but de demeurer concis. Donc il veut mieux avoir quelques bases de prog pour comprendre...

Les différentes étapes :
- poser des hypothèses sur le problème
- interface : nom du programme + entrées/sorties
- principe de résolution : écrire les algorythmes en français
- language de programmation : écriture du programme

- quelques trucs non classés :

10 div 2 (donne le résultat de la division=5)
11 mod 2 (donne le reste de la divsion=1)
signes={>,<,=,<>,>=,<=,+,-,*)
begin... end; (équivalent des parenthèses pour une suite d'instructions)
() (les paranthéses pour les calculs)
ord(X) (renvoie le n° d'ordre de X dans son type)
succ(X) et pred(X) (servent respectivement à renvoyer la variable suivante dans son type, et la précédente)
chr(X) (renvoie le caractère associé à X, avec X=0->255)
NOT (l'inverse d'une expression)
AND/OR (=et/ou ; expressions logiques pour les conditionnelles par ex)
[1..10] (définie l'intervalle de 1 à 10)

I. 3 instructions fondamentales

- affectation

V:=15
V:=V+1 (incrémentation)
V:=V-1 (décrémentation)

- lire (saisie)

read(A)
readln(a) (retour à la ligne)

- écrire

write(A)
writeln('bonjour') (retour à la ligne)

on précède les caractères spéciaux par ' (write('salut j''ai faim');)

II. Structure interne d'un programme

program nom_du_prog; {nom du prog}
uses crt; {bibliothèques}
var...; {déclaration des variables}
const...; {déclaration des constantes}
type...; {définition des types}
begin {début des instructions}
...;
end. {fin des instructions}

- chaque commande se termine par ';'
- les commentaires se notent entre {}

III. Les conditionnelles

- simples

if X=0

then write('X nul...')
else write('X pas nul');

/!\ pas de ";" avant le else car 'if-then-else' une seule instruction
- multiples (selon...)

case X of

0:write('X nul');
1:write('X = 1');
2:write('X=2');
else write('X pas =0 ni 1 ni 2')

end; {case X of}

IV. Itération (les boucles)

- FOR (=pour)

FOR I:=1 TO 25 DO
writeln(I);

=pour I de I à 25, ecrire I
(s'emploie lorsqu'on sait d'avance le nombre d'exécution de la boucle)
(le compteur est incrémenté quand on utilise TO et décrémenté quand on utilise DOWNTO)

- WHILE (=tant que condition vraie)

WHILE (I<=2*N) DO
begin
write('c''est pas encore bon');
read(I);
end;

(tant que I est <= 2N, on répète la boucle sinon on en sort)
(la condition est vérifiée au début de la boucle donc la boucle ne s'exécute pas si la condition est remplie)

- REPEAT (répéter jusqu'à ce que condition soit vraie)

REPEAT

writeln('Voulez vous continuer ? O)ui ou N)on');
read(rep);

UNTIL (rep='o') OR (rep='O');

(pas besoin de begin... end à cause du UNTIL qui définie la fin de la boucle)
(la boucle se répète au moins une fois car la condition est vérifiée à la fin)

V. Les types, variables, constantes & expressions

Un type spécifie l'ensemble des valeurs qui peuvent etre affectées à l'objet et déterminent implicitement l'ensemble des applications applicables à l'objet
- types des variables

var X:integer;

(exemple de déclaration de variable : X est un entier)

integer=entier
real=réel
boolean=booléen (true ou false)
array=tableau
char=1 caractère
string=une suite de caractères
word=entier positif

(les constantes se déclarent ainsi : CONST X=25;)

- création de nouveaux types

type

jour=(lundi,mardi,mercredi,jeudi,vendredi,samedi,dimanche);

(le type contient les jours de la semaine avec lundi considéré comme le premier (0) et dimanche le dernier (6))

VI. Les tableaux & record

ARRAY [x] OF y;

x:ce sont les numéros des cases
y:ce sont les valeurs prisent par ces cases
ex : array[1..10] of integer = tableau de 10 cases contenant des entiers

- tableaux à plusieurs dimensions : array[lignes,colonnes] of integer (pareil pour 3, 4 ... dimensions)
- les cellules d'un tableau sont toutes de meme type

RECORD bagnole
begin

marque:t_marque;
age:integer;
couleur:t_couleur

end;

record = tableau composés de cellules de types différents
- pour lire la marque de la deuxième bagnole du record : writeln(bagnole.marque[2];)
- avec l'instruction WITH (équivalent à ci-dessus) :

WITH bagnole DO

writeln(marque[2]);

- meme propriétés que les tableaux (seule opération possible : l'affectation case par case)

VI. La modularité

Les fonctions et les procédures sont des sous-programmes; on les déclare avant le begin du prog principal ;
et on les appelle après, en spécifiant les variables en entrée et celles en sortie

FUNCTION calculer1 (x:integer):integer;

begin
writeln('tu as donné x, moi je te calcule x²...');
calculer1:=(x*x);
end;

code pour appeler la fonction (à insérer dans le prog principal) : calculer1(variable);
on en déduit le fonctionnement des fonctions :

- c'est simplement l'équivalent de y=f(x), ou f est la function

PROCEDURE calculer2 (x,y:integer; var x1,y1:integer;);

begin
writeln('moi j''te calcule x² et y²');
x1:=x*x;
y1:=y*y;
end;

code pour appeler la procédure : calculer2(4,5,sortie1,sortie2)
lors de l'exécution, le programme associe 4 à x, 5 à y, sortie1 à x1 et sortie2 à y1. on en déduit le fonctionnement des procédures :

- écriture : PROCEDURE nom_procedure (entrées:type_entrées ; VAR sorties:type_sorties);

begin
--- contenu du sous-programme ---
end;

- la différence entre function & procédure ? les functions ne peuvent avoir qu'une variable en sortie, et de type simple.
Ainsi on ne déclare pas la variable de sortie d'une fonction