TD4

LE TD3 étant une reflexion sur les pointeurs en salle de cours, nous passons directement au TD4. Ce TD est identique au TD2 si ce n'est que les piles sont traitées non plus avec des tableau mais avec des pointeurs.

td2.adb

with Ada.Text_Io; use Ada.Text_Io;
with Ada.Integer_text_Io; use Ada.Integer_Text_Io;

with traitement_pile; use traitement_pile;

procedure td2 is
-- specification
-- {preconditions : - }
-- {postconditions : - }
pile : t_pointeur;
choix : integer;
element : integer;
element_retour : integer;

	procedure inverser(pile : in out t_pointeur) is
	-- specification
	-- {preconditions : - }
	-- {postconditions : les elements de la pile sont inverses}
	pile_sauvegarde : t_pointeur;
	pile_sauvegarde2 : t_pointeur;
	longueur : integer;
	begin
		initialiser_pile(pile_sauvegarde);
		initialiser_pile(pile_sauvegarde2);
		longueur := taille_pile(pile);
		for i in 1..longueur loop
			depiler(pile,element_retour);
			empiler(pile_sauvegarde,element_retour);
		end loop;

		for i in 1..longueur loop
			depiler(pile_sauvegarde,element_retour);
			empiler(pile_sauvegarde2, element_retour);
		end loop;

		for i in 1..longueur loop
			depiler(pile_sauvegarde2,element_retour);
			empiler(pile, element_retour);
		end loop;
	end;

begin

new_line;
put("/**************************************+");
new_line;
put("+          TD4 : LES PILES             +");
new_line;
put("+**************************************/");
new_line;
new_line;

initialiser_pile(pile);

while choix /= 0 loop
	put("1- Empiler un élément");
	new_line;
	put("2- Depiler la pile");
	new_line;
	put("3- Tester si la pile est vide");
	new_line;
	--put("4- Tester si la pile est pleine");
	--new_line;
	put("5- Donner la taille de la pile");
	new_line;
	put("6- Bonus : inverser la pile");
	new_line;
	put("7- Réinitialiser la pile");
	new_line;
	put("0- Quitter le programme");
	new_line;
	put("Votre choix : ");
	get(choix);
	new_line;

if choix = 1 then
	--if pile_pleine(pile) then put("la pile est pleine");
	--else 
		put("Entrez l'élément à  empiler");
		new_line;
		get(element);
		empiler(pile,element);
		put("manipulation effectuée avec succès");
	--end if;
	new_line;
	new_line;
end if;
if choix = 2 then
	if pile_vide(pile) then put("la pile est vide");
	else 
		depiler(pile, element_retour);
		put("La pile a été dépilée. L'élément ");
		put(element_retour);
		put(" a été supprimé.");
	end if;
	new_line;
	new_line;
end if;
if choix = 3 then
	if pile_vide(pile) then put("la pile est vide");
	new_line;
	new_line;
	else put("la pile n'est pas vide");
	new_line;
	new_line;
	end if;
end if;
--if choix = 4 then – Procedure inutile avec un traitement de pile avec liste chainée
--	if pile_pleine(pile) then put("la pile est pleine");
--	new_line;
--	new_line;
--	else put("la pile n'est pas pleine");
--	new_line;
--	new_line;
--	end if;
--end if;
if choix = 5 then
	put("la taille de la pile est");
	put(taille_pile(pile));
	new_line;
	new_line;
end if;
if choix = 6 then
	inverser(pile);
	put("pile inversée");
	new_line;
	new_line;
end if;
if choix = 7 then 
	initialiser_pile(pile);
	put("pile initialisée");
	new_line;
	new_line;
end if;
if choix = 8 then 
	afficher(pile);
end if;

end loop;

end td2;

Traitement_pile.adb

with Ada.Text_Io; use Ada.Text_Io;
with Ada.Integer_text_Io; use Ada.Integer_Text_Io;

with traitement_pile;

package body traitement_pile is

	procedure initialiser_pile(pile : in out t_pointeur) is
	-- specification
	-- {preconditions : - }
	-- {postconditions : la pile entree en parametre est initialisee }
	begin
	pile := null;
	end initialiser_pile;

	procedure empiler(pile : in out t_pointeur; element : in integer) is
	-- specification
	-- {preconditions : - }
	-- {postconditions : l'élément est empilé sur la pile }
	P : t_pointeur;
	begin	
	P := new t_cellule;
	P.info := element;
	P.suivant := pile;
	pile := P;
	end empiler;

	procedure depiler(pile : in out t_pointeur; element_retour : out integer) is
	-- specification
	-- {preconditions : - }
	-- {postconditions : la pile est depilée }
	begin
	element_retour := pile.info;
	pile := pile.suivant;
	end depiler;

	function pile_vide(pile : t_pointeur) return boolean is
	-- specification
	-- {preconditions : - }
	-- {postconditions : renvoie vrai si la pile est vide et faux si elle ne l'est pas }
	begin
	if pile = null then
		return true;
		else return false;
	end if;
	end pile_vide;

	--function pile_pleine(pile : t_pointeur) return boolean is
	-- specification
	-- {preconditions : - }
	-- {postconditions : renvoie vrai si la pile est pleine et faux si elle ne l'est pas }
	--begin
	--return false;
	--end pile_pleine;

	function taille_pile(pile : t_pointeur) return integer is
	-- specification
	-- {preconditions : - }
	-- {postconditions : renvoie la taille de la pile
	taille : integer;
	r : t_pointeur;
	begin
	r := pile;
	taille := 0;
	while r.suivant /= null loop
		taille := taille+1;
		r:= r.suivant;
	end loop;
	taille := taille+1;
	return taille;
	end taille_pile;

end traitement_pile;

traitement_pile.ads

package traitement_pile is

type t_cellule;
type t_pointeur is access t_cellule;

type t_cellule is record
	info : integer;
	suivant : t_pointeur;
end record;

procedure initialiser_pile(pile : in out t_pointeur);
procedure empiler(pile : in out t_pointeur; element : in integer);
procedure depiler(pile : in out t_pointeur; element_retour : out integer);
function pile_vide(pile : t_pointeur) return boolean;
function pile_pleine(pile : t_pointeur) return boolean;
function taille_pile(pile : t_pointeur) return integer;

end traitement_pile;