Généralement, un programme est un peu compliqué avec des morceaux qui se répètent. Pour représenter cela, au lieu de réécrire 50 fois le même bout de code, on utilise des sous-programmes. En Ada, il existe deux types de sous-programmes, les procédures et les fonctions. En gros c'est la même chose, avec juste ce qu'il faut de différences pour que ce soit rigolo et que ca prenne la tête (on fait de l'Ada quand même).

Les procédures

Tous les programmes rencontrés jusqu'ici se composent d'une unique procédure, qui est exécutée au lancement du programme. Ces procédures ne prennent pas d’arguments mais c’est bien sûr un cas particulier. Dans le cas général, une procédure se définit là ou on peut définit une variable ou un type et suit le schéma suivant : procedure nom_de_la_procédure(liste des arguments) is déclaration des variables, des types, des sous-procédure begin liste d’instructions end nom_de_la_procédure; Comme on l’a déjà vu, si la liste des arguments est vide, on omet les parenthèses (et pour le fun, elles sont même interdites). La liste des arguments ressemble fortement à une liste de déclarations de variables. En effet, une liste d’arguments s’écrit comme ceci : nom_de_la_variable : [type_d_acces] type_de_la_variable; list_des_arguments_suivants Rien que du classique, excepté le type d’accès. Il y a 3 types d’accès à une variable :

• in: le mode par défaut : l’appelant donne la valeur de l’argument et elle ne sera pas modifiée par la procédure.
• out : dans ce mode, la valeur de l’argument n’est pas définie au début de l’exécution de la procédure et c’est la procédure qui va la calculer et le résultat sera accessible à l’appelant.
•  
• in out : l’appelant va spécifier la valeur initiale du paramètre mais la procédure va la changer et l’appelant aura accès à ce résultat.

Ces mode d’accès ressemblent au passage par valeur ou par référence des autres langages mais attention, ici on dit juste ce qu’on veut faire de ce paramètre, la façon dont il sera effectivement passé (par valeur ou par référence) sera déterminé par le compilateur, pas besoin de s’en préoccuper (ce qui veux dire que ceux qui ne savent pas ce que veux dire passage par valeur ou par référence n’ont aucune question à se poser).

Les fonctions

Les fonctions sont des procédures avec UNIQUEMENT des paramètres en mode in mais qui renvoient une unique valeur. Un e fonction s’écrit de manière similaire à une procédure : function nom_de_la_fonction[(liste_des_arguments)] return type_de_la_valeur_retourne is déclaration des variables, des types, des sous-procédure begin liste d’instructions end nom_de_la_fonctione; Le renvoie d’une valeur s’effectue vie l’instruction return. Il faut que dans tous les cas possibles, la fonction passe par un return, sinon le compilateur criera au scandale. Un petit mot sur les surcharges : il est possible, en Ada, de définir 2 fonctions ou procédures ayant le même nom du moment qu’il est possible de les différencier parce que leurs arguments ne sont pas du même type ou leur type de retour est différent.

Valeur par défaut

Il est possible de donner une valeur par défaut aux arguments de type in. Cela se fait, comme pour les déclarations de variable, simplement en ajoutant := valeur après la type de la variable. Par exemple function pv(n : in Float := 1.0; T : in Float := 273.0) return Float is R : constant Float := 8.314472; begin return n*R*T; end pv;

Appels de sous-programmes

L’appel de sous-programmes se fait simplement en écrivant son nom, suivit, entre parenthèses, de la liste des arguments. Pour cette liste d’arguments, il existe 2 méthodes. Soit on les donne dans l’ordre défini par le sous-programme ( c'est mal!), soit on utilise l’opérateur =>. Par exemple, pour appeler pv définis ci-dessus, on peut faire

• pv(2.0, 10.0)
• pv(T=>10.0, n=>2.0)
•  
• pv(2.0, T=>10.0)

La 3ème méthode est un mix des 2 premières. On peut donner les 1ers arguments dans l’ordre de la définition et ensuite les suivant par leur nom. Attention, une fois que l’on a donne un argument par son nom, on ne peut pas donner les suivant sans préciser leur nom. pv(2.0, T=>10.0) est valide mais pas pv(n=2.0, 10.0).

Déclaration de sous-programmes

Il peut arriver qu’on ait besoin de dire au compilateur qu’une fonction existe, sans vouloir dire tout de suite ce qu’elle fait. L’exemple typique est une récurrence croisée : une procédure p1 appelle p2 qui elle-même appelle p1. Comment faire ? La réponse est assez simple, il suffit de déclarer p2 avant la définition de p1, puis celle de p2. Une déclaration reprend la 1ere ligne de la définition d’un sous-programme, en remplaçant le is par un ; Par exemple pour p1 et p2 : procedure p2; procedure p1 is begin p2; end p1; procedure p2 is begin p1; end p2;