Les types simples et structurés

A. Les types simples

Les objets d'un type simple ne peuvent pas être décomposés. Tous les types "primitifs" et scalaires sont simples. Les types scalaires sont des ensembles des valeurs discrètes lesquelles peuvent être numérotées. Tous les types scalaires sont codés par des entiers. Ils possèdent un plus petit et un plus grand élément. Pour toute valeur v on peut obtenir son code ord(v), qui est un entier. Par exemple ord('A') vaut 65, ord(False) vaut 0, ord(true) vaut 1. Pour toute valeur qui n'est pas la plus petite on peut obtenir la valeur immédiatement précédente - pred(v) et si elle n'est pas la plus grande - la valeur suivante - succ(v).

1. Les types énumérés.

Ce sont des types dont les valeurs sont représentées par des noms qui sont les constantes du type. On peut donner un nom au nouveau type:

arcEnCiel = (ROUGE, ORANGE, JAUNE, VERT, BLEU, VIOLET);
semaine = (DIMANCHE, LUNDI, MARDI, MERCREDI, JEUDI, VENDREDI, SAMEDI);

ils sont codés 0,1,2,...

sexe = (MASCULIN,FEMININ);

On peut déclarer des variables de ces types :

VAR c1 ,c2, c3 : arcEnCiel;

jour : semaine;

2. Les types intervalles

On définit les intervalles en en donnant la borne inférieure et la borne supérieure.

5..10
ROUGE .. JAUNE
'A' .. 'Z'

L'intervalle et le type de base sont compatibles, c'est à dire que peut affecter les valeurs d'un type aux variables d'autre, mais quand le type de la variable est un intervalle la valeur ne doit pas l'excéder.

TYPE
arcEnCiel = (ROUGE, ORANGE, JAUNE, VERT, BLEU, VIOLET);
coul_chaude = ROUGE .. JAUNE;
VAR
c1 : arcEnCiel; c2 : coul_chaude;
BEGIN
c2 := ORANGE; c1 := succ(c2); c2:=c1;
....

B. Les types structurés ou composés

1. Les tableaux

1a) Les tableaux à une dimension

Les tableaux sont composés d'objets tous de même type. Le nombre d'éléments doit être fixe et est indiqué par l'ensemble des indices choisis pour les distinguer.

ARRAY [typeIndice] OF type_des_elements

Le type des éléments (de base) peut être n'importe quel type déjà définit sauf un fichier. Le typeIndice peut être n'importe quel type scalaire.

Exemples:

TYPE
ligne = Array [1..80] of char;
vecteur = array[1..3] of real;
compteurs = array[char] of integer;
VAR
v : vecteur;
t : array[1..10] of integer;

Si on a déclaré la variable

t : array [typeIndice] Of typeElem

la notation t[ei] ei est une expression de type typeIndice désigne un des éléments du tableau t. Le type de t[ei] est typeElem et le nombre des éléments est égal au nombre des objets de type typeIndice.

Traitement d'une liste par balayage de ces éléments.

Soit A un tableau avec 10 éléments.

A: array [1..10] of .....

For i := 1 To 10 Do
Traitement de A[i]

Exemple: Faire la somme des N nombres réels.

Program Somme_N;
Const Nmax = 10;
Type
 Tableau = Array[1..Nmax] Of Real;
Var
 A : Tableau;
 s : Real; N,i : integer;
Begin
 Repeat
  Write('Entrez N: '); Readln(N);
 Until (N>0) And (N<=Nmax);
 For i:=1 To N Do
 Begin
  Write('Entrez A[',i,']: ');
  Readln(A[i]);
 End;
 s:=0;{Initialisation}
 For i:=1 To N Do s := s+A[i];
 Writeln('La somme est =',s:10:3);
End.

Exemple 2: Trouver le maximum de N nombres réels.

max:=0;{Initialisation}
For i:=1 To N Do
If A[i] > max Then max := A[i];

{On n'a montré que les modifications principales}

Exemple 3: Compter combien de fois chaque lettre minuscule est utilisée dans une ligne.

Program Compter_les_lettres;
Type
 lettres = 'a'..'z';
 compteurs = Array [lettres] Of Integer;
Var
 comp: compteurs;
 c : char;
Begin
 For
c := 'a' To 'z' Do
   comp[c] := 0;
 c:=' ';
 While not eoln Do
 Begin
  Read(c);
  If (c >='a') and ('c'<='z') Then
    comp[c] := comp[c] + 1;
 End;
 For
c := 'a' To 'z' Do
  Writeln(c,comp[c]:3);
End.

1b) Les tableaux multidimensionnels

Le type des éléments (de base) d'un tableau peut être n'importe quel type, donc il peut être un type tableau lui-même

m : Array[1..10] Of Array[1..20] Of Real;

Les éléments de m : m[1], m[2], ...,m[10] sont des tableau dont les éléments: m[1][1],...,m[1][20],m[2,1],...,m[2,20],m3,1],...,m[10,1],...,m[10,20] sont des réels.

Une instruction équivalente de déclaration:

m : Array[1..10,1..20] Of Real;

De même les éléments peuvent être notés: m[1,1],..,m[1,20],m[2,1],...,m[2,20

On peut représenter un tableau bidimensionnel comme une matrice

Traitement d'un tableau bideminsionnel

colonnes

j

m11 m12 .... m1,20
lignes i m21 m22 .... m2,20
.... .... .... ....
m10,1 m10,2 .... m10,20

For i := 1 To 10 Do
For
j := 1 To 20 Do
Traitement de m[i,j]

Exemple: Faire la somme des éléments d'une matrice réelle.

Program Somme_N;
Const Nmax = 10;
Type
Matrice = Array[1..Nmax,1..Nmax] Of Real;
Var
A : Matrice;
s : Real; N,i : integer;
Begin
Repeat
Write('Entrez N: '); Readln(N);
Until (N>0) And (N<=Nmax);
For i:=1 To M Do Begin
Write('Entrez ligne',i,': ');
For j:=1 To N Do Read (A[i]);
Readln;
End;
s:=0;{Initialisation}
For i:=1 To M Do
For j := 1 To N Do s := s+A[i];
Writeln('La somme est =',s:10:3);
End.

Exercices: 1.Faire la somme des éléments positifs.
2. Faire la somme des éléments avec des indices pairs.
3. Trouver le la valeur d'élément maximal d'une matrice est sa place
.

2. Les structures ou les enregistrements ("records")

Les structures (records en Pascal) permettent de construire des ensemblages de composants de types divers qui sont considérés comme un tout. La définition d'une structure a la forme:

record
nom1 : type1;
nom2 : type2;
......
nomn : typen
end

nom1, nom2 etc. sont les noms des composants qui s'appellent champs de la structure (enregistrement). Ils peuvent être de n'importe quel type simple ou structuré défini en avant sauf un fichier.

Exemple: Un étudiant de la filière francophone sera identifié par un nom (une chaîne de caractères), et un numéro. On lui associera son sexe, sa date de naissance et les notes qu'il a pour le premier semestre. Ces 5 pièces d'information forment un tout puisqu'elles concernent une même personne. On ne peut les réunir en un tableau car elles sont des types différents. (Ci dessous on utilise le type string pour chaîne de caractères)

TYPE
sexe = (MASCULIN,FEMININ);
datetype = Record
jour : 1..31;
mois : 1..12;
année : integer
End;
etudiant = Record
numero : integer;
nom : string[30];
sex : sexe;
date : datetype;
notes : Array[1..4] Of
integer
End;

On peut déclarer des variables de ce type:
et : etudiant;

Chaque champ possède un nom qui s'appelle sélecteur est joue un rôle similaire à celui des indices des tableaux. Pour sélectionner un champ il suffit d'écrire :
nom de variable.nom de champs

Les diverses parties de l'étudiant seront notées:
et.numero et.nom et.date et.sexe et.notes

Si Tabet est un tableau d'étudiants déclaré comme:
Tabet : Array[1..40] Of etudiant;
Tabet[5].date.jour est le jour de naissance du 5eme étudiant,. Tabet[5].notes[3] est la 3eme note du 6eme étudiant.

Représentation dans la mémoire
numero
nom
sex
jour
etudiant date mois
annee
1
2
notes 3
4
5

Exemple: Calculer les moyennes des notes des tous étudiants:

Program Moyennes;
Type
 sexe = (MASCULIN,FEMININ);
 datetype = Record
  jour : 1..31;
  mois : 1..12;
  année : integer
 End;
 etudiant = Record
  numero : integer;
  nom : string[30];
  sex : sexe;
  date : datetype;
  notes : Array[1..4] Of integer
 End;
Var
 Tabet: Array[1..40] Of etudiant;
 i,j,sex,s,N : integer;
Begin
 Repeat
  Write('Entrer N; ');Readln(N);
 Until (N>0) And (N<=40);
 For i:= 1 To N Do
 Begin
  Writeln('Entrez les donnees     pour etudiant ' ,i);
  Readln(Tabet[i].nom);
  Readln(Tabet[i].numero,sex,     Tabet[i].date.jour,     Tabet[i].date.mois,
    Tabet[i].date.annee);
  If sex =0 Then
    Tabet[i].sex :=MASCULIN
  Else Tabet[i].sex := FEMININ;
  For j := 1 To 4 Do    Read(Tabet[i].notes[j]);
  Readln;
 End;
 For i := 1 To N Do
 Begin
  s := 0;
  For j := 1 To 4 Do
    s:=s+Tabet[i].notes[j];
  Writeln(Tabet[i].nom:30,s/4:6:2);
 End;
End.