Je vous arrête tout de suite : il ne s'agit pas de monstres ou de types avec des pouvoirs spéciaux ! Non, un type mutant est simplement un type structuré qui peut muter, c'est-à-dire changer. Je vais pour cela reprendre mon type T_Bulletin. Attention ça va aller très vite :
Code : Ada
type T_Bulletin(classe : T_Classe := PRIMAIRE) is record
--PARTIE FIXE
francais, math, sport : float ; --ou float range 0.0..20.0 ; --PARTIE VARIABLE : COLLEGE ET LYCEE
case classe is when PRIMAIRE =>
null ;
when COLLEGE | LYCEE =>
Partie 3 : Ada, les types composites 86/312
lv1, bio : float ; --PARTIE SPECIFIQUE AU LYCEE case classe is when LYCEE =>
chimie, lv2 : float ; when others =>
null ; end case ; end case ; end record ;
Euh… T'aurais pas oublier de faire une modification après ton copier-coller ?
Non, regardez bien mon paramètre classe tout en haut : il a désormais une valeur par défaut : PRIMAIRE ! Vous allez me dire que ça ne change pas grand chose, et pourtant si ! Ainsi vous allez pouvoir écrire :
Code : Ada
Eric : T_Eleve ; -- non prédéfini Bltn_Eric : T_Bulletin ;
pas la peine d'indiquer un paramètre, il est déjà prédéfini
Et désormais, Bltn_Eric est un type mutant, il va pouvoir changer de structure en cours d'algorithme ! Nous pourrons ainsi écrire :
Code : Ada
... Eric : T_Eleve ; Bltn_Eric : T_Bulletin ; BEGIN
Bltn_Eric := (COLLEGE,12.5,13.0,9.5,15.0,8.0) ; Bltn_Eric := Bltn_Kevin ; --On suppose bien-sûr que Bltn_Kevin est déjà "prérempli"
...
Par contre, comme le fait d'attribuer une classe à Bltn_Eric va modifier toute sa structure, il est interdit de noter uniquement :
Code : Ada
Bltn_Eric.classe := COLLEGE ;
Toute changement de la composante classe doit se faire de manière «globale», c'est-à-dire «tout en une seule fois» !
Autre contrainte, si vous déclarez votre objet Bltn_Eric de la manière suivante : Code : Ada
Bltn_Eric : T_Bulletin(COLLEGE) ;
Alors votre objet ne sera plus mutable ! On revient au cas d'un simple type structuré polymorphe. Donc ne spécifiez pas la classe durant la déclaration si vous souhaitez pouvoir changer la structure.
Toujours plus loin !
Pour aller plus loin il serait judicieux de «fusionner» les types T_Eleve et T_Bulletin de la manière suivante : Code : Ada
type T_Bulletin(classe : T_Classe := PRIMAIRE) is --!!! POUR L'INSTANT, PAS DE CHANGEMENTS !!!
record --PARTIE FIXE
francais, math, sport : float ; --ou float range 0.0..20.0 ; --PARTIE VARIABLE : COLLEGE ET LYCEE
case classe is when PRIMAIRE =>
null ;
when COLLEGE | LYCEE =>
lv1, bio : float ; --PARTIE SPECIFIQUE AU LYCEE case classe is when LYCEE =>
chimie, lv2 : float ; when others =>
null ; end case ; end case ; end record ;
type T_Eleve is
--!!! LA MODIFICATION SE FAIT ICI --!!!
record
nom : string(1..20) ; prenom : string(1..20) ; bulletin : T_Bulletin ; end record ;
Inutile de garder deux types : le type T_Bulletin sera intégré au type T_Eleve. En revanche, il faudra que le type T_Eleve soit déclaré après le type T_Bulletin. Si cela se révélait impossible, vous pouvez toujours éviter ce problème en écrivant la spécification de T_Eleve, puis en décrivant T_Bulletin et enfin T_Eleve :
Code : Ada
type T_Eleve ; -- !!! AJOUT D'UNE SPECIFICATION !!! Le reste ne change pas.
type T_Bulletin(classe : T_Classe := PRIMAIRE) is record
...
end record ;
type T_Eleve is record ...
end record ;
Plus besoin non plus de garder une composante classe au sein du type T_Eleve puisqu'elle existe déjà dans la composante bulletin !
Vous voilà désormais armés pour créer vos propres types (modulaires, énumérés, sous-types, structurés [non paramétré, polymorphe ou mutant]). Combiné à l'usage des tableaux, voilà qui élargit vraiment nos horizons et nos possibilités. Si nous développions notre type T_Eleve et les fonctionnalités qui s'y rapportent, nous pourrions créer un package volumineux et complet permettant d'établir une sorte de base de données des élèves d'un établissement : création et modification d'un «fichier élève» enregistrant de nombreuse variables de type T_Eleve, le numéro de téléphone, l'adresse, les notes par matière (dans des tableaux inclus dans le type T_Eleve)… la seule limite est votre imagination et votre temps libre.
D'ailleurs, nous allons réaliser ce genre de programme dans le prochain chapitre : il s'agira de créer un logiciel gérant, non pas des
Partie 3 : Ada, les types composites 87/312
élèves, mais votre collection de CD, DVD… Comme vous l'avez deviné, notre prochain chapitre ne sera pas théorique, ce sera un TP ! Alors, si certains points vous posent encore problème, n'hésitez pas à les revoir.
En résumé :
Un sous-type ou SUBTYPE, est une restriction d'un type préexistant. Par conséquent, les sous-types bénéficient de toutes les fonctionnalités offertes au type initial.
Préférez créer un type énuméré plutôt que de représenter certaines propriétés par des nombres. Il est plus simple de comprendre qu'une personne est de sexe masculin que de comprendre que son sexe est le n°0.
Les types articles ou structurés sont créées à l'aide du mot-clé RECORD. Contrairement aux tableaux, ils permettent de rassembler de nombreuses informations de types très divers dans des composantes. Ces composantes peuvent être elles-mêmes des types articles.
Les types articles peuvent être paramétrés à la manière des fonctions. Ce paramétrage permet de créer des types polymorphes, c'est à dire qu'une partie de la structure du type dépendra du paramètre fourni. Lorsqu'un variable de type polymorphe est déclarée, son type doit absolument être paramétré.
En fournissant une valeur par défaut au paramètre, vous pouvez définir un type mutant dont la structure pourra évoluer au cours de votre code. Plus aucun paramétrage n'est alors nécessaire à la déclaration de votre variable.