Cours ADA les déclarations de variables et de constantes

LES TYPES ABSTRAITS

Un type de données abstrait caractérise :
– un ensemble de valeur,
– un ensemble d’opérations applicables aux objets du type.

Généralités

Ada dispose de plusieurs classes de types :
– les types de données scalaires (entiers, réels, caractères…),
– les types de données composites (tableaux et articles),
– les types de données accès (pointeur),
– les types de données privés,
– les sous-types et les types dérivés.

Types de données scalaires

On distingue les types entiers, réels et énumératifs. On donne ci-dessous un tableau récapitulatif (non exhaustif). Les types entiers et énumératifs représentent les types discrets.
L’utilisateur peut définir de nouveaux types de la façon suivante :
type indice is range 1..50 ;
type mass is digit 10 ; — type point flottant
type voltage is delta 0.1 range –5.0..+5.0 ; — type point fixe
type couleur is (bleu, rouge, jaune) ;

Les attributs

Les types abstraits possèdent des attributs qui les décrivent… et que l’on peut référencer selon la syntaxe suivante ; on donne l’exemple d’un tableau :
tableau : array (1..10) of integer ;
tableau’range
tableau’first
tableau’last

Les déclarations de variables et de constantes

Les types de données ne fournissent qu’un mécanisme pour décrire la structure de données. Les déclarations, quant à elles, crée des instances (des objets) d’un type donné. En Ada, les déclarations d’objets permettent de créer des variables et des constantes.
Voici par exemple des déclarations de variable :
compteur : integer ;
anniversaire : date ;
mon_tampon : piles.pile ;
Voici des déclarations d’objets constantes :
pi : constant := 3.14 ;
telephone : constant integer := 05_49_55_06_50 ;

Les conversions de types

Le langage Ada est fortement typé, ce qui signifie qu’on ne peut pas combiner directement des objets de types différents. Il faut procéder à des conversions de type explicites (avec la fonction de conversion appropriée), comme suit :
type chiffre is integer range 0..9 ;
c : chiffre ;
x : integer ;
c := 5 ;
x := integer(c) ;
Il est possible cependant d’inhiber la vérification de type au moyen de la procédure unchecked_conversion !

Types anonymes

Considérons les exemples suivants d’utilisation d’un type tableau anonyme :
a : array (1..100) of integer ;
b : array (1..100) of integer ;
Bien que a et b paraissent de même type, le compilateur n’est pas en mesure de le reconnaître ; ce qui signifie que l’on ne pourra pas écrire :
a := b ;
si l’envie nous en prenait ! Cependant il est toujours possible de convertir la variable a, comme suit :
type mes_tableaux is array (1..100) of integer ; c : mes_tableaux ;
c := mes_tableau(a) ;

Les tableaux

Quelques exemples

– tableau indexé par un type énumératif défini par l’utilisateur : type pixel is array (couleur) of float ;
– type tableau à six éléments d’un type défini par l’utilisateur : type capteur is array (index range 5..10) of voltage ;
– tableau à deux dimensions :
type echiquier is array (1..8,1..8) of couleur ;

Deux types de déclaration pour les tableaux

– Les tableaux contraints : La taille du tableau est connue à la compilation. Voici la définition d’un tableau d’entier de 100 cases.
type indice is range (1..100) ;
type mes_tableaux is array(indice) of integer ;
– Les tableaux non contraints : La taille du tableau est seulement connue à l’exécution du programme.
type mes_tableaux is array(integer range < >) of character ;
v : mes_tableaux(1..100) ;
– Les tableaux dynamiques : Pointeurs…
Utilisation des agrégats pour l’initialisation des tableaux
On distingue trois catégories d’agrégats :
– les agrégats définis par position : a(1..5) := (3,6,9,12,15) ; ???
– les agrégats définis par nom : ??? a(1..5) := (5 => 15, 4 => 12, 1 => 3, 3 => 9, 2 => 6) ; lignes’(1|15 => ‘*’, others => ‘u’) ; m := (1..25 (1..25 => 1)) ; — initialisation d’un tableau 25×25
– les agrégats mixes : On mélange les deux techniques précédentes…
type couleur is (blanc, bleu, rouge, jaune, noir) ; type drapeau_tricolore is array(1..3) ;
drapeau_france : drapeau_tricolore(bleu, 3 => rouge, 2 => blanc) ;

Les chaînes de caractères

Le type chaîne de caractère est un type tableau non contraint prédéfini :
type string is array(positive range < >) of character ;
L’affectation de chaîne est complète, c’est à dire qu’il est interdit d’écrire :
chaine : string(1..20) ;
chaine := « toto » ;
On dispose de la fonction concaténation $ des chaînes de caractères dont les spécifications sont les suivantes :
– character $ character  string
– string $ character  string
– character $ string  string
– string $ string  string
Considérons les exemples suivants d’utilisation de cette fonction :
c : character ;
s : string(5..10) ;
t : string(15..20) ;
Bien observer le résultat des opérations qui suivent (le premier indice gagne) :
c $ s ; — 1..6
s $ c ; — 5..11
c $ s ; — 5..16

Les articles

Quelques exemples

Considérons les exemples suivants :
– article à trois composants :
type date is record
jour : integer range 1..31 ;
mois : integer range 1..12 ;
annee : natural ;
end record ;
– article à cinq composants :
type vanne is record
nom : string(1..20) ;
emplacement : string(1..30) ;
ouverte : boolean ;
debit : float range 0.0..30.0 ;
verifiee : date ;
end record ;

Utilisation des agrégats pour l’initialisation des articles

De la même manière que pour les tableaux, on utilise les agrégats pour initialiser des articles :
anniversaire : date’(12,10,1978) ;
anniversaire : date’(jour => 12, mois => 10, annee => 78) ;

Les types de données accès

Lorsque des objets doivent être manipulées dynamiquement, il convient d’utiliser des valeurs accès qui pointent sur des objets.
La syntaxe est la suivante :
type pointeur_tampon is access tampon ;
Par défaut, les variables de type accès sont initialisée à null.

LES BASES DU ADA
CONSTANTES LITTERALES
NOMS
Renommage
Surcharge des noms
OPERATEURS
Opérateurs standards
Surcharge des opérateurs
INSTRUCTIONS
Contrôle séquentiel
Contrôle conditionnel
Contrôle itératif
LES TYPES ABSTRAITS
GENERALITES
Types de données scalaires
Les attributs
Les déclarations de variables et de constantes
Les conversions de types
Types anonymes
LES TABLEAUX
Quelques exemples
Deux types de déclaration pour les tableaux
Utilisation des agrégats pour l’initialisation des tableaux
Les chaînes de caractères
LES ARTICLES
Quelques exemples
Utilisation des agrégats pour l’initialisation des articles
LES TYPES DE DONNEES ACCES
Utilisation de new pour la création d’un objet dynamique
LES TYPES DERIVES
Mécanisme d’héritage
Surcharge de fonction héritée
LES TYPES PRIVES
Type private
Type limited private
LES SOUS-TYPES
UNITES DE PROGRAMMES
SOUS-PROGRAMMES
Fonction
Procédure
Paramètres entrée / sortie
Appel de sous-programme
PAQUETAGES
Définition
Utilisation des types privés
Utilisation d’un paquetage
TACHES
TRAITEMENT D’EXCEPTIONS
UNITES DE PROGRAMME GENERIQUES
LES PARAMETRES GENERIQUES
Types génériques
Mode in, in out
Paramètres par défaut
Instanciation par nom ou par position
SOUS-PROGRAMME GENERIQUE
PARAMETRE GENERIQUE EN SOUS-PROGRAMME
PAQUETAGE GENERIQUE