- Types simples
- Intervalles
- Enregistrements
- Enumerations
Bien que le Turbo Pascal soit un langage où les types de variables sont sur-abondants, il est possible au
programmeur de créer ses propres types.
Les types doivent être déclarés avec le mot-clef Type avant la déclaration des variables (normal).
Types simples
Par défaut, une chaîne de caractères à une longueur maximale de 255 caractères. Il est possible de modifier
ce comportement et de spécifier un type de chaîne de carctères de 8 caractères maximum, pour contenir le nom
d'un fichier par exemple.
Si l'utilisateur futur du programme donne une chaîne de plus de 8 caractères à la variable, la chaîne sera alors
tronquée.
Pour définir le type, on écrira tout simplement :
Type NomFichier = String[8];
Ensuite, on peut déclarer une valeur du type NomFichier :
Type NomFichier = String[8];{Déclaration du type NomFichier}
var Fichier : NomFichier;{Utilisation du type NomFichier}
begin
writeln('Entrez le nom d''un fichier.');
write('Seuls les 8 premiers caractères sont pris en compte : ');
read(Fichier);
writeln('Vous avez écris : ', Fichier);
end.
Il est également possible de déclarer des nouveaux types de variables Integer, Byte
ou de n'importe quel type intégré, mais l'intéret est discutable :
Type Octet = Byte;
Type Mot = Integer;
type DMot = LongInt;
varUnOctet : Octet;
UnMot : Mot;
UnDMot : LongInt;
On peut aussi déclarer des nouveaux type du type Array. Par exemple, on peut imaginer un type Array qui aura seulement
une dimension de 3 :
Type Podium = array [1..3] of String;
varTourDeFrance : Podium;
begin
TourDeFrance[1] := 'Armstrong';
TourDeFrance[2] := 'Ullrich';
TourDeFrance[3] := 'Beloki';
TourDeFrance[4] := 'Kivilev';{Cette ligne provoque une erreur !!}
end.
Intervalles
Parfois, il est possible que l'on veuille qu'une variable ne puisse prendre une valeur qu'à l'intérieur d'une certaine fourchette (par exemple, entre
1 et 5).
Il est alors possible de définir un interval. Un interval ne peut être que du type entier ou du type caractère.
Pour définir un interval de 1 à 5, on écrira :
Type Arrivee = 1..5;
Pour définir un interval de la lettre I à N, on écrira :
Type Annuaire = 'I'..'N';
Ensuite, on utilise ce type comme n'importe quel autre type :
type TCuisson = 10..30;{De 10 à 30}
var Gateau : TCuisson;{Ne peut prendre que des valeurs de 10 à 30}
begin
write('Entrez le temps de cuisson du gateau : ');
readln(Gateau);
end.
Si on essaye tout de même de faire rentrer une valeur supérieur ou inférieur à l'interval, une erreur se produira.
Enregistrements
Nous avons déjà rencontré ce genre de type dans les sections antérieures. Pour prendre un exemple la procédure GetTextSettings de l'unité
Graph. Elle utilise un type de variable du type enregistrement se nommant TextSettingsType qui est le suivant :
TextSettingsType = RECORD
Font : WORD;
Direction : WORD;
CharSize : WORD;
Horiz : WORD;
Vert : WORD;
END;
Si on déclare une variable su type TextSettingsType, on poura alors accéder à chacun de ces champs (Font, Direction,
CharSize, Horiz et Vert) à l'aide de l'opérateur point (.) :
uses Graph;
varMesReglages : TextSettingsType;
begin
MesReglages.Font := TriplexFont;
MesReglages.Direction := HorizDir;
MesReglages.CharSize := UserCharSize;
MesReglages.Horiz := RightText;
MesReglages.Vert := BottomText;
end.
Vous remarquez que dans le cas présent, nous n'avons pas eu à définir le type TextSettingsType puisque celui-ci l'est déjà au sein de
l'unité Grahp.
Le Turbo Pascal possede une instruction permettant d'établir une réference à la variable en cours, pour simplifier le boulot. Il s'agit de l'instruction
With..Do. Entre With et Do, on indique le nom de la variable. Ensuite, on déclare un bloc d'instruction (Begin...end)
et à l'intérieur de celui-ci, il n'est plus necaissaire d'indiquer le nom de la variable pour accéder à ces champs.
Ainsi :
uses Graph;
varMesReglages : TextSettingsType;
begin
With MesReglages Do
begin
Font := TriplexFont;
Direction := HorizDir;
CharSize := UserCharSize;
Horiz := RightText;
Vert := BottomText;
end;
end.
Donc, si pour un programme destiné à une entreprise, on avait par exemple à gérer les employés, on pourai créer un type TEmploye tel
que celui-ci :
Type TEmploye = RECORD
Nom : String[20];
Prenom : String[20];
Fonction : String[20];
Salaire : LongInt;
end;
Attention cependant! La taille maximal d'un type enregistrement est de 65520 octets. C'est pourquoi nous avons limité les champs du type String
à 20 caractères.
Ensuite, on l'utilisera comme n'importe quel type :
Type TEmploye = RECORD
Nom : String[20];
Prenom : String[20];
Fonction : String[20];
Salaire : LongInt;
end;
varPersonnel : Array[1..100] Of TEmploye;
i : integer;
begin
for i := 1 To 100 do
begin
with Personnel[i] do
begin
writeln('Employé n°', i);
write('Nom : ');
readln(Nom);
write('Prenom : ');
readln(Prenom);
write('Fonction : ');
readln(Fonction);
write('Salaire : ');
readln(Salaire);
end;
end;
end.
Il est aussi possible de définir des champs d'un type enregistement qui soit eux même du type enregistrement. Par exemple :
Type TEmploye = RECORD
Nom : String[20];
Prenom : String[20];
Fonction : String[20];
Salaire : LongInt;
Embauche : RECORD{Un enregistrement dans un enregistrement}
Jour : 1..31;
Mois : 1..12;
Annee : 1900..2000;
end;
end;
ou encore mieux :
Type TDate = RECORD
Jour : 1..31;
Mois : 1..12;
Annee : 1900..2000;
end;
Type TEmploye = RECORD
Nom : String[20];
Prenom : String[20];
Fonction : String[20];
Salaire : LongInt;
Embauche : TDate;{Type TDate défini ci-dessus}
DateNaissance : TDate;{Type TDate défini ci-dessus}
end;
Il est également possible d'utiliser une strucutre en Case...Of à l'intérieur d'un type RECORD.
On poura ainsi plus ou moins personaliser (en théorie) le type en fontion des parametres transmis.
Par exemple :
Type TPedalier = RECORD
Grand : Byte;
Petit : Byte;
Case Triple : Boolean Of
true : (Milieu : Byte);
false : ();
end;
Dans l'exemple ci-dessus, le champs Milieu est normalement créé QUE si le champs Triple est
à true.
L'exemple ci-dessous montre qu'il n'en est rien :
Type TPedalier = RECORD
Grand : Byte;
Petit : Byte;
Case Triple : Boolean Of
true : (Milieu : Byte);
false : ();
end;
varShimano : TPedalier;
begin
Shimano.Triple := false;{Donc le champs Milieu n'existe pas}
writeln(Shimano.Milieu);{et ben si!}
end.
Enumerations
Les enumerations ne sont pas à proprement parler un type de variable, mais plutôt une enumeration de constantes. Une variable déclarée ensuite de ce
type ne poura prendre pour valeur qu'une constante appartenant à cette énumeration.
D'autant plus que la valeur de ces constantes ne peut pas être définie.
Par exemple, prenons pour parametre le temps qu'il fait à l'exterieur. Nous considérerons qu'il peut faire Beau, Maussade ou Mitigé.
Nous pouvons ensuite créer un type regroupant ces trois constantes et une variable utilisant ce type :
Type Temps = (Beau, Maussade, Mitige);
var Lundi : Temps;
La variable Lundi ne peut prendre pour valeur que Beau, Maussade ou Mitige :
Type Temps = (Beau, Maussade, Mitige);
varLundi : Temps;
UnReel : Real;
begin
Lundi := Beau;{OK}
Lundi := Maussade;{OK}
Lundi := 10;{!!ERREUR!!)
Lundi := 1;{!!ERREUR!!}
UnReel := Mitige;{!!ERREUR!!}
writeln(Lundi);{!!ERREUR!!}
end.
On constate également que seules les variables du type Temps peuvent recevoir les constantes Beau, Maussade
et Mitige.
Mais à quoi sert donc ce genre de type? Il est utilisé dans les calculs sur les ensembles, ou bien dans des applications telles que celle-ci :
Type Temps = (Beau, Maussade, Mitige);
varLundi : Temps;
begin
if Lundi = Beau Then
writeln('Bonne journée')
else if Lundi = Maussade Then
writeln('Sortez vos bottes')
else if Lundi = Mitige Then
writeln('Prenez un parapluie, on ne sait jamais');
end.
|
Accueil
Membres
Forum
Articles
Download
Sondages
Outils
Scriptland
ProgBoards
Chahdortt Djavann, Bas les voiles !
