L'instruction de choix multiple:
Nous avons vu que l'instruction de rupture de séquence (if-then-else) permet de séparer tous les cas possibles d'une solution. Dans des situations où la différenciation des cas se base sur la valeur d'une variable, et si cette variable peut prendre un nombre important de valeurs, l'utilisation de l'instruction if- then-else devient encombrante.
Exemple : on veut écrire un programme qui lit le numéro du mois et affiche le nom de ce mois. Ce programme peut être écrit ainsi:
Program nom_du_mois ;
Var
mois: 1..12 ;
Begin
Readln (mois) ;
If (mois=l) Then Writeln ('Janvier')
Else If mois=2 then Writeln ('Fevrier')
Else If mois=3 Then Writeln ('Mars')
Else If ……………………..
End.
Il est évident que l'écriture du programme de cette manière, bien qu'elle soit possible, donne lieu à un programme peu lisible. C'est pour ce genre de situation que Pascal met à la disposition du programmeur une structure de contrôle qui permet une écriture plus claire du programme. Il s'agit de l'instruction Case. La résolution de l'exemple ci-dessus en utilisant l'instruction Case peut être écrite de la manière suivante:
Case mois of
1 : writeln ('Janvier');
2 : Writeln('Fevrier') ;
3 : writeln (‘Mars') ;
…………………
12 : Writeln(‘Decembre’)
End ;
Remarques: . La variable utilisée dans l'instruction Case pour différencier les cas est appelée sélecteur. . Les différentes valeurs que peut prendre le sélecteur sont appelées des étiquettes.
. Après chaque étiquette on peut écrire une seule instruction (ou bien une instruction composée).
. Quand l'instruction Case est exécutée le sélecteur est évalué, si sa valeur est égale à l 'une des étiquettes l'instruction qui suit cette étiquette est exécutée puis l'exécution se poursuit à l'instruction suivante.
. il est possible de regrouper des étiquettes dans le cas où elles correspondent au même traitement.
Par exemple le fragment de programme suivant affiche le nombre de jours du mois:
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Case mois of
1,3,5,7,8,10, 12: writeln ('nombre de jours : ‘, 31);
2: wrileln ('nombre de jours: ‘ ,28) ;
4,6,9,11: writeln ('nombre de jours :’ , 30)
End ;
. Le sélecteur de l'instruction Case doit être d'un type ordinal (Integer, Boolean, Char, type
énuméré, type intervalle).
. il arrive parfois que pour certaines valeurs du sélecteur aucune action ne soit prévue, dans ce cas l'instruction qui suit cette étiquette est réduite à un point virgule.
. Dans le cas d'étiquettes successives il est possible de les écrire sous forme d'intervalle.
Exemple:
Var
jour: (samedi, dimanche, lundi, mardi, mercredi, jeudi, vendredi);
Begin
…………………
Case jour of
samedi..mardi : writeln ( Aller à l'université') ;
mercredi: writeln ('Faire le Marche:) ;
jeudi: ;
vendredi: writeln ('Visilè de famille')
End;
4. Le type tableau (array):
a) Définition: Un tableau est une collection ordonnée de variables ayant toutes le même type et qui partagent le même nom. Par exemple, nous pouvons employer un tableau de caractères pour représenter une ligne de texte, ou un tableau de réels pour représenter un vecteur. Une matrice est constituée de colonnes, chacune de ces colonnes étant un vecteur, et peut donc être représentée par un tableau de vecteurs.
b) Déclaration d'un type tableau:
La déclaration d'un type tableau se fait dans la section de déclaration de types en utilisant le descripteur de type ARRAY, comme dans l'exemple suivant:
type
vecteur = array [1..10] of real;
Dans cette exemple, on a déclaré le type 'vecteur' qui représente un tableau à dix composantes réelles. Une variab1e de type 'vecteur' représente en fait dix variables de type réel différenciée par un indice qui varie de 1à 10. Une Variable de type ‘vecteur’ peut être déclarée, dans la section de déclaration de variables, en utilisant l'identificateur de type 'vecteur’. Par exemple:
var
i: 1..10;
x : vecteur;
Dans cet exemple, i est une variable de type intervalle (1..10) qui sera utilisée comme indice de la variable x de type 'vecteur'. Les composantes du vecteur x sont écrites comme suit:
X[l] x[2] x[3] ... x[9] et x[10], ou alors x[i].
Règles relatives au type tableau :
. il est possible de remplacer les déclarations plus haut par :
var
x: array [1..10] of real ;
mais, comme il a été mentionné auparavant, il est préférable de séparer les déclarations de type des déclarations des variables. .'
. L'indice d'un tableau est souvent d'un type intervalle, aussi est il préférable de déclarer le type intervalle avant le type tableau comme dans l'exemple suivant:
type
indice = 1..10 ;
vecteur = array [indice] of real ;
. il est possible d'utiliser un type énuméré comme type de l'indice d'un tableau, comme dans l’exemple :
type
semaine = (samedi, dimanche, lundi, mardi, mercredi, jeudi, vendredi);
heures = array [semaine] of integer;
var
ahmed : heures;
on peut imaginer que la variable ahmed est un vecteur dont les composante sont égales au
nombre d'heures supplémentaires faites par fonctionnaire nommée ahmed pendant chaque jour de semaine. Ces composantes s'écrivent:
ahmed[samedi], ahmed[dimanche],..........., ahmed[Vedredi].
. Les composantes d'un tableau sont des variables simples dont le type est le type de la base du tableau et peuvent être utilisées comme toute variable simple suivant les règles de Pascal.
Exemple :
var
x : vecteur;
i : indice;
a : real ;
begin
. . . . .. .. . . . ...
x[i] := a ;
………………
. La lecture des composantes d'un vecteur (tableau à une dimension), ainsi que la plupart des opérations qui manipulent les composantes d'un vecteur, passe souvent par l'utilisation d'une boucle For. L'exemple suivant calcule la norme d'un vecteur :
Exemple :
var
x : vecteur ;
i : indice;
begin
(* lecture des composantes du vecteur x*)
for i:= 1 to 10 do
read (x[i]) ;
end.
. Il est possible d'affecter la valeur d'un tableau à un autre tableau de même type par une simple affectation comme dans l'exemple suivant:
var
x, y : vecteur;
begin
. . . .. . . . . ... . .. . .
y :=x;
. . . . . . . . .. .. . . . ..
end.
Cette affectation remplace en fait la boucle suivante (1 est une variable de type 1.10) :
For I:= 1 to 10 do
y[I] := x[I] ;
. Les composantes d'un même tableau sont stockées en mémoire dans des emplacements successifs. Le nombre d'octets utilisés est fonction du type de base du tableau.
c) Exemples d'application :
Nous allons traiter dans cette partie deux exemples d’applications des tableaux à une dimension (ou vecteurs;). Le premier calcule le produit scalaire de deux vecteurs et le second recherche le minimum d’un vecteur.
Produit scalaire de deux vecteurs: on définit le produit scalaire de deux vecteurs X et Y à n composantes comme étant le scalaire P = Σ xi yi i=1 to N d'où le programme suivant:
Program Produitscalaire ;
Const
N=10;
Type
Indice = l..N ;
Vect = Array [Indice] of Real ;
Var
X, Y : Vect ;
I : Indice;
Somme, P : Real ;
Begin
For I := 1 to N do
Read (X[I]) ;
For I:= 1 to N do
Read (Y[I]) ;
Somme := 0 ;
For I := 1 to N do
Somme:= Somme + X[I]*Y[I] ;
P := sqrt (Somme);
Writeln ('Le produit scalaire X.Y = ‘, P: 10:4)
End.
Recherche du minimum d'un vecteur:
Soit un vecteur X à n composantes, on recherche la plus petite composante de ce vecteur. On suppose que les types 'Indice' et 'Vect' sont définis Comme dans l’exemple précédent.
Program RechercheMinimum;
…………………………
Var
X : Vect ;
I : Indice;
M : Real;
Begin
(* lecture du vecteur X *)
M := X[ 1] ; (* on suppose que le minimum est la première composante *)
For I:= 2 To N Do
If M> X[I] Then M:= X[I] ;
Writeln ('Le minimum est: ‘, M: 10:4) ;
End.
Dim 18 Sep - 13:58 par maachou mohamed
normalment larbit kan reservé!
bonne journéé