with Piles; with Ada.Text_IO; use Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; with Ada.Characters.Latin_1; -- des constantes comme Apostrophe (Latin1 ?!?!) use Ada.Characters.Latin_1; -- Programme de test du module Pile. procedure Utiliser_Piles is -- Utiliser la pile pour en montrer les possibilités sur un exemples. --! Attention, même si on utiliser « pragma Assert », on ne peut pas --! vraiment considérer cette procédure comme un programme de tests. --! Il est souhaitables que chaque programmes de test soit court, --! indépendant des autres et teste un aspect. procedure Utiliser_Pile_Caractere is package Pile_Caractere_3 is new Piles (Capacite => 3, T_Element => Character); --! On a nommé les paramètres de généricité. On peut ne pas les --! nommer à condition de respecter l'ordre --! --! package Pile_Caractere_3 is --! new Piles (3, Character); use Pile_Caractere_3; procedure Afficher_Pile is new Afficher (Afficher_Element => Put); Pile : T_Pile; begin Put_Line ("Tester_Pile_Caractere"); -- initilaiser la pile Initialiser (Pile); pragma Assert (Est_Vide (Pile)); -- empiler un premier élément Empiler (Pile, 'A'); pragma Assert (not Est_Vide (Pile)); pragma Assert (not Est_Pleine (Pile)); pragma Assert ('A' = Sommet (Pile)); -- remplir la pile Empiler (Pile, 'B'); pragma Assert ('B' = Sommet (Pile)); Empiler (Pile, 'C'); pragma Assert ('C' = Sommet (Pile)); pragma Assert (not Est_Vide (Pile)); pragma Assert (Est_Pleine (Pile)); -- Afficher la pile Afficher_Pile (Pile); New_Line; -- supprimer un éléments Depiler (Pile); pragma Assert (not Est_Pleine (Pile)); pragma Assert ('B' = Sommet (Pile)); -- ajouter un élément Empiler (Pile, 'D'); pragma Assert ('D' = Sommet (Pile)); pragma Assert (Est_Pleine (Pile)); -- Afficher la pile Afficher_Pile (Pile); New_Line; -- vider la pile Depiler (Pile); pragma Assert (not Est_Vide (Pile)); pragma Assert ('B' = Sommet (Pile)); Depiler (Pile); pragma Assert (not Est_Vide (Pile)); pragma Assert ('A' = Sommet (Pile)); Depiler (Pile); pragma Assert (Est_Vide (Pile)); -- Afficher la pile Afficher_Pile (Pile); New_Line; end Utiliser_Pile_Caractere; procedure Utiliser_Pile_Entier is -- Capacite de la pile de test. Capacite : constant Integer := 10; package Pile_Integer is new Piles(Capacite, Integer); use Pile_Integer; -- Afficher un entier. --! On ne peut pas directement utliser Put car cette procédure ne --! prend pas qu'un seul paramètre. Elle n'a donc pas la bonne --! signature. --! Pour éviter de devoir définir cette procédure plusieurs fois, on --! pourrait la définir dans un autre module ou unité, par exemple --! afficher_un_entier.ads/.adb. procedure Afficher_Entier (N: in Integer) is begin Put (N, 1); end Afficher_Entier; procedure Afficher is new Pile_Integer.Afficher (Afficher_Entier); --! On pourrait ne pas mettre Pile_Integer et --! nommer Afficher_Entier simplement Afficher. P1 : T_Pile; begin Put_Line ("Tester_Pile_Entier"); -- initilaiser la pile Initialiser (P1); pragma Assert (Est_Vide (P1)); -- remplir la pile for I in 1..Capacite loop Empiler (P1, I); end loop; pragma Assert (Est_Pleine (P1)); -- Afficher la pile Afficher (P1); New_Line; -- vider la pile for I in reverse 1..Capacite loop pragma Assert (I = Sommet (P1)); Depiler (P1); end loop; pragma Assert (Est_Vide (P1)); end Utiliser_Pile_Entier; procedure Illustrer_Surcharge is package Pile_Integer is new Piles(10, Integer); use Pile_Integer; procedure Afficher (N: in Integer) is begin Put (N, 1); end Afficher; procedure Afficher is new Pile_Integer.Afficher (Afficher); --! Il y a deux procédures qui s'appelle Afficher : --! 1. Afficher (Integer), --! 2. Afficher (Pile_Integer.T_Pile) : instance de la 1. --! --! Ceci ne pose pas de problème car en fonction du paramètre --! effectif fourni : Integer ou T_Pile, le compilateur saura --! laquelle choisir. --! --! Remarque : on doit mettre Pile_Integer.Afficher parce que --! Ada ne veut pas que l'instance Afficher (T_Pile) porte le même nom --! que la procédure générique (risque de masquage). P : T_Pile; begin Put_Line ("Illustrer_Surcharge"); Initialiser (P); Empiler (P, 5); Put ("5 = "); Afficher (5); New_Line; --! la 1 : afficher entier Put ("P = "); Afficher (P); New_Line; --! la 2 : afficher pile --! Décommenter la ligne suivante et compiler pour voir l'erreur --! signalée par le compilateur et les versions de Afficher qu'il --! connait. -- Afficher("XXX"); --! utiliser_piles.adb:167:18: expected private type "T_Pile" defined at piles.ads:9, instance at line 134 --! utiliser_piles.adb:167:18: found a string type --! utiliser_piles.adb:167:18: ==> in call to "Afficher" at line 143 --! utiliser_piles.adb:167:18: ==> in call to "Afficher" at line 138 end Illustrer_Surcharge; -- Afficher le caractère C entre apostrophes. procedure Afficher(C : in Character) is begin Put (Apostrophe & C & Apostrophe); end Afficher; procedure Illustrer_Plusieurs_Afficher_Pour_Meme_Pile is package PPC3 is new Piles (Capacite => 3, T_Element => Character); use PPC3; procedure Afficher is new PPC3.Afficher (Put); procedure Afficher_Apostrophe is new PPC3.Afficher (Afficher); --! Ici, il faut un nom différent pour les deux procédures car --! elles ont la même signature : une T_Pile de PPC3. P: T_Pile; begin Put_Line ("Illustrer_Plusieurs_Afficher_Pour_Meme_Pile"); Initialiser (P); Empiler (P, 'A'); Put ("P = "); Afficher (P); New_Line; Put ("P = "); Afficher_Apostrophe (P); New_Line; end Illustrer_Plusieurs_Afficher_Pour_Meme_Pile; -- Montrer deux instances du même module dans le même sous-programme. procedure Illustrer_Plusieurs_Piles is package PPC1 is new Piles(3, Character); use PPC1; procedure Afficher is new PPC1.Afficher (Put); package PPC2 is new Piles(10, Character); use PPC2; procedure Afficher is new PPC2.Afficher (Put); procedure Afficher_Apostrophe is new PPC2.Afficher (Afficher); PC1 : PPC1.T_Pile; PC2 : PPC2.T_Pile; begin Put_Line ("Illustrer_Plusieurs_Piles"); --! Décommenter la ligne suivante et compiler pour voir l'erreur --! signalée par le compilateur et les versions de Afficher qu'il --! connait. -- Afficher("XXX"); --! utiliser_piles.adb:220:09: no candidate interpretations match the actuals: --! utiliser_piles.adb:220:18: expected private type "T_Pile" defined at piles.ads:9, instance at line 206 --! utiliser_piles.adb:220:18: found a string type --! utiliser_piles.adb:220:18: ==> in call to "Afficher" at line 212 --! utiliser_piles.adb:220:18: ==> in call to "Afficher" at line 207 --! utiliser_piles.adb:220:18: ==> in call to "Afficher" at line 177 -- Initialiser les piles Initialiser (PC1); Initialiser (PC2); -- Ajouter des éléments dans les piles for C in Character range 'A'..'C' loop Empiler (PC1, C); Empiler (PC2, C); end loop; -- Afficher les piles Put ("PC1 = "); Afficher (PC1); New_Line; Put ("PC2 = "); Afficher (PC2); New_Line; Put ("PC2 = "); Afficher_Apostrophe (PC2); New_Line; -- Ne pas respecter un contrat for C in Character range 'A'..'Z' loop Empiler (PC1, C); end loop; Afficher (PC1); end Illustrer_Plusieurs_Piles; begin Utiliser_Pile_Caractere; Utiliser_Pile_Entier; Illustrer_Surcharge; Illustrer_Plusieurs_Afficher_Pour_Meme_Pile; Illustrer_Plusieurs_Piles; end Utiliser_Piles;