Accueil » L'Ada

5 - Les attributs, les énumerations

Les attributs

Les attributs sont un peu comme les membres static d'une classe en Java. C'est à dire que les attributs sont des fonctions ou des valeurs rattachées à un type. Par exemple, le plus petit Integer est une propriété des Integer. La syntaxe pour les utiliser est la suivante : nom_de_type'nom_de_l'attribut[(liste des arguments)] par exemple :

 plus_petit_entier : Integer := Integer'First; plus_grand_entier : Integer := Integer'Last;

Parmi les attributs les plus utiles, on trouve

  •  
 type'Image(x : type) : renvoie x sous forme de chaîne de caractères (équivalent de la fonction toString de Java)
  •  
 type'Value(s : String) : attribut réciproque de Image, parse la chaîne de caractères s pour créer un objet de type type

Exemple de petit programme (il existe de meilleures façons de lire un entier, c'est juste pour l'exemple)

with Text_IO; use Text_IO; 
procedure attrib is
  nombre1 : Integer;
  nombre2 : Integer;
begin 
  Put("Entrez un nombre (entre " & Integer'Image(Integer'First) 
      & " et " & Integer'Image(Integer'Last) & ") : ");
  nombre1 := Integer'Value(Get_Line);
  Put("Entrez un 2nd nombre : ");
  nombre2 := Integer'Value(Get_Line);
  Put_Line("Le plus grand est " & Integer'Image(Integer'Max(nombre2, nombre2)));
end attrib;

Les énumérations

Une énumération est un ensemble fini d'éléments, défini par la liste de ses éléments (enum en C), par exemple (rouge, vert, bleu) est une énumération. La syntaxe Ada pour déclarer une énumération est la suivante :

 type nom_de_mon_enumeration is (liste_des_valeurs);

La définition d'une énumération définit implicitement un ordre : le premier est le plus petit, le dernier le plus grand. Une énumération à n éléments est donc très proches de l'ensemble des entiers de 1 à n. Il existe d'ailleurs un certain nombre d'attributs qui s'appliquent aux énumérations et aux entiers (ici i est un entier et x et y des éléments de l'énumération) :

  •  
 Pos(x) : donne le numéro de x parmis les valeurs de l'énumération
  •  
 Val(i) : donne le ième élément de l'énumération
  •  
 First : donne le 1er élément de l'énumération
  •  
 Last : donne le dernier élément de l'énumération
  •  
 Succ(x) : donne l'élément suivant dans l'énumeration
  •  
 Prec(x) : donne l'élément précedent dans l'énumeration
  •  
 Min(x, y) : donne l'élément defini en 1er dans la liste
  •  
 Max(x, y) : donne l'élément defini en dernier dans la liste

NOTE1: Par défaut, les éléments sont indicés à partir de 0 NOTE2: On peut définir une valeur numérique pour chaque élément :

type abc is (a, b, c); for abc use (a=>12, b=>37, c=>42);

NOTE3: Tenter d'accéder au successeur du dernier, au prédécesseur du premier, ou encore à l'élément à partir d'un indice invalide lève bien sûr une exception.
Exemple de petit programme (comme d'habitude, on peut faire beaucoup mieux : en Ada il exite un moyen de représenter les ensembles $ \frac{\mathbb{Z}}{n\mathbb{Z}} $ facilement)

 with Text_IO; use Text_IO;
 procedure enum is
   type Zsur4Z is (Zero, Un, Deux, Trois);
   Acc : Zsur4Z := Zero;
 begin
   loop 
     Put_Line("Acc vaut " & Zsur4Z'Image(Acc));
     Put("Combien voulez vous ajouter ? ");
     declare
       number : Integer := Integer'Value(Get_Line);
     begin
       exit when number = 0;
       Acc := Zsur4Z'Val((Zsur4Z'Pos(Acc) + number) mod 4);
     end;
   end loop;
 end enum;