Université des Sciences et Technologies de Lille
Licence Miage - Programmation 1


Cours 1 : structures de base

1   Organisation générale d'un programme ADA

Un programme ADA s'articule autour d'un programme principal qui utilise le plus souvent des paquetages correspondant à des unités cohérentes :

Structure du programme principal

with nom_paquetage1;
use nom_paquetage1;
procedure nom_procedure is
partie déclarative
begin
corps de la procédure
end nom_procedure;
Le fichier s'appelle obligatoirement nom_procedure.adb. La clause with permet d'accéder aux fonctionnalités du paquetage nom_paquetage1. La clause use est ensuite facultative, mais bien pratique : elle permet d'invoquer les fonctionnalités de nom_paquetage1 directement, sans préfixer l'appel de nom_paquetage1. On peut l'utiliser tant qu'il n'y a pas de risque d'ambiguité avec un autre paquetage.

Structure d'un paquetage

Un paquetage se partage en deux fichiers :

2   Les fonction et les procédures

Les fonctions

function Nom_fonction(arg1:type1;arg2:type 2...) return type_resultat is
partie déclarative
begin
instructions
return ...;
end Nom_fonction;
Les arguments d'une fonction sont accessibles en lecture uniquement. En particulier, il est hors de question de modifier leur valeur lors de l'exécution de la fonction.

Dans la spécification d'un paquetage, l'information qui apparait est
function Nom_fonction(arg1:type1; arg2:type 2...) return type_resultat;

Les procédures

procedure Nom_procedure(arg1:mode1 type1; arg2:mode2 type 2...) is
partie déclarative
begin
instructions
end Nom_procedure;
Pour chaque paramètre de la procédure, il faut préciser la modalité de passage : Dans la spécification d'un paquetage, l'information qui apparait est
procedure Nom_procedure(arg1:mode1 type1; arg2:mode2 type 2...);

3   La partie déclarative

Elle contient

4   Les types prédéfinis (rapidement)

Les types INTEGER (et ses sous-types), CHARACTER et BOOLEAN ont en commun d'être des types discrets : les valeurs sont totalement ordonnées, avec un prédecesseur et un succésseur. Par exemple, 2 est le successeur de 1 et le prédecesseur de 3. De même, 'c' est le successeur de 'b' et le prédecesseur de 'd'. Nous verrons par la suite que ces types bénéficient d'attributs spécifiques qui facilitent leur manipulation.

5   Structures de base

Chaque instruction est terminée par ;. L'affectation se fait avec := et les opérateurs de comparaison sont  = (égalité), /= (différence), <, >, <= , >=, in (appartenance à un intervalle), not in.

Structures conditionnelles

Il y a un If then else classique, dont la partie else est facultative, et un second avec des conditions imbriquées.

if condition then
...
else
...
end if;
      
if condition then
...
elsif condition2
...
elsif condition3
...
end if;

Il est également possible de faire des choix multiples.

case expression is
when choix1 => ...
when choix2 => ...
...
when others => ...
end case;
La variable expression est de type discret : Integer, Boolean, Character. L'énumération des cas doit être exhaustive (couvrir toutes les possibilités). Cela explique qu'il faut souvent avoir recours au cas par défaut others, éventuellement avec l'instruction null.

Structures itératives

for indice in {reverse} intervalle loop
...
end loop;
      
while condition loop
...
end loop;

Notez-bien : L'indice d'une boucle est de type discret, comme INTEGER ou CHARACTER, et c'est une variable muette. Cela signifie que cette variable n'a pas à être déclarée et que sa valeur ne peut pas être modifiée par des instructions explicites.

intervalle décrit l'intervalle de variation de l'indice ce la boucle. Il est de la forme debut .. fin où debut et fin sont des valeurs discrètes. Par exemple 2..5 ou 'a'..'z'. Si on veut que le compteur de boucle décroit de, disons, 5 à 2, il faut préciser que l'intervalle doit être parcouru en sens inverse: reverse 2..5 (et non 5..2, qui est un intervalle vide).

6   Entrées-sorties

Les fonctionnalités d'entrées-sorties sont disponibles dans le paquetage TEXT_IO pour les chaînes de caractères et ADA.INTEGER_TEXT_IO pour les entiers.

get(...) entrée (texte, caractère et entier)
put(...) sortie (texte, caractère et entier)
put_line(...) affichage et saut de ligne (uniquement pour du texte)
new_line changement de ligne
Avec tout ça, vous êtes capable d'écrire votre premier programme hello.adb:

   with Text_Io; use Text_Io; 
   procedure hello is
   begin
      put ("Hello world!");
   end hello;
Hélène Touzet - octobre 2001