8×01-02: Modulo genérico Pila estático con tipo abstracto de datos TAD

-- 06/03/2012
-- 1. Implementa un módulo genérico con el TAD (Tipo Abstracto de datos) pila, pero haciendo uso de una implementación estática.
-- 2. Crea un programa con un menú que permita hacer las operaciones del ejercicio anterior y vaya mostrando los resultados obtenidos. Haz que la pila quede instanciada para almacenar enteros.

-- Se implementa una pila estática genérica con un vector, esto es que cada nodo será un componente del vector, y que el nodo podrá ser de cualquier tipo: entero, carácter, booleano, un registro, etc.



-- Librerías:
with
 ada.text_io,
 ada.integer_text_io,
 pila_estatica; -- Agregamos nuestro Paquete/Librería.
use
 ada.text_io,
 ada.integer_text_io;



-- Programa principal:
procedure ada8x01 is

	-- Se crea un registro con los parámetros necesarios para usarse como Nodo en la Pila.
	type miNodo is record
		num:integer;
		car:character;
	end record;

	-- Se indica el tamaño máximo de la pila estática.
	max:positive := 4;

	-- Usamos el paquete pila_estatica. Se le envía el número de nodos y el tipo de dato que se guardara en cada componente de la pila (que es un vector).
	-- Si añadimos la sentencia "use p;" podremos usar las funciones del paquete sin mas, en cambio si no lo hacemos tendremos que usarlas añadiendo "p." al principio de la función, ejemplo: "p.insertar(pila,nodo);"
	package p is new pila_estatica( max, miNodo );
	-- use p;

	-- Variables:
	temp:miNodo;		-- Nodo "temporal" para que el usuario o la función leer/extraer lo rellenen con la información.
	pila:p.miPila;		-- Pila de tipo miPila (de la librería p. (pila_estatica))
	eleccion:integer;


	-- Instrucciones del programa principal:
	begin


		-- Primer menu:
		put_line("Menu:");
		put_line(" 1. Inicializar la Pila");
		put_line(" 0. Salir");
		get(eleccion);
		while eleccion not in 0..1 loop
			put( "Opcion no valida, pruebe de nuevo: " ); get(eleccion);
		end loop;


		-- Si se eligió inicializar la pila, se ejecutara el resto del programa:
		if eleccion = 1 then

			-- Se inicializa la pila poniendo la cima a 0:
			p.inicializar(pila);

			-- Segundo menu:
			new_line;
			put_line("Menu:");
			put_line(" 1. Insertar");
			put_line(" 2. Extraer");
			put_line(" 3. Solo leer");
			put_line(" 0. Salir");


			while eleccion /= 0 loop

				get(eleccion);
				while eleccion not in 0..3 loop
					put( "Opcion no valida, pruebe de nuevo: " ); get(eleccion);
				end loop;


				case eleccion is

					-- Insertar:
					when 1 =>
						if p.indice(pila) < max then
							put("Inserte un numero de DNI:  "); get(temp.num);
							put("Insertar la letra del DNI: "); get(temp.car);
							p.insertar(pila, temp);
						else
							put_line("La pila esta llena.");
						end if;


					-- Extraer:
					when 2 =>
						if p.indice(pila) > 0 then
							p.extraer(pila, temp);
							put("El DNI extraido: "); put(temp.num); put(temp.car); new_line;
						else
							put_line("La pila no tiene informacion.");
						end if;


					-- Leer:
					when 3 =>
						if p.indice(pila) > 0 then
							temp := p.leer(pila);
							put("El DNI leido: "); put(temp.num); put(temp.car); new_line;
						else
							put_line("La pila no tiene informacion.");
						end if;


					-- Salir:
					when 0 => NULL;
					when others => NULL;

				end case;

				new_line; new_line;
				if eleccion /= 0 then
					put_line("Operacion realizada, elija otra opcion del menu superior:");
				end if;

			end loop;


		end if;


end ada8x01;

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

-- 06/03/2012

-- 1. Implementa un módulo genérico con el TAD (Tipo Abstracto de datos) pila, pero haciendo uso de una implementación estática.

-- 2. Crea un programa con un menú que permita hacer las operaciones del ejercicio anterior y vaya mostrando los resultados obtenidos. Haz que la pila quede instanciada para almacenar enteros.

-- Se implementa una pila estática genérica con un vector, esto es que cada nodo será un componente del vector, y que el nodo podrá ser de cualquier tipo: entero, carácter, booleano, un registro, etc.

-- Librerías:

with

ada.text_io,

ada.integer_text_io,

pila_estatica; -- Agregamos nuestro Paquete/Librería.

use

ada.text_io,

ada.integer_text_io;

-- Programa principal:

procedure ada8x01 is

-- Se crea un registro con los parámetros necesarios para usarse como Nodo en la Pila.

type miNodo is record

num:integer;

car:character;

end record;

-- Se indica el tamaño máximo de la pila estática.

max:positive := 4;

-- Usamos el paquete pila_estatica. Se le envía el número de nodos y el tipo de dato que se guardara en cada componente de la pila (que es un vector).

-- Si añadimos la sentencia "use p;" podremos usar las funciones del paquete sin mas, en cambio si no lo hacemos tendremos que usarlas añadiendo "p." al principio de la función, ejemplo: "p.insertar(pila,nodo);"

package p is new pila_estatica( max, miNodo );

-- use p;

-- Variables:

temp:miNodo; -- Nodo "temporal" para que el usuario o la función leer/extraer lo rellenen con la información.

pila:p.miPila; -- Pila de tipo miPila (de la librería p. (pila_estatica))

eleccion:integer;

-- Instrucciones del programa principal:

begin

-- Primer menu:

put_line("Menu:");

put_line(" 1. Inicializar la Pila");

put_line(" 0. Salir");

get(eleccion);

while eleccion not in 0..1 loop

put( "Opcion no valida, pruebe de nuevo: " ); get(eleccion);

end loop;

-- Si se eligió inicializar la pila, se ejecutara el resto del programa:

if eleccion = 1 then

-- Se inicializa la pila poniendo la cima a 0:

p.inicializar(pila);

-- Segundo menu:

new_line;

put_line("Menu:");

put_line(" 1. Insertar");

put_line(" 2. Extraer");

put_line(" 3. Solo leer");

put_line(" 0. Salir");

while eleccion /= 0 loop

get(eleccion);

while eleccion not in 0..3 loop

put( "Opcion no valida, pruebe de nuevo: " ); get(eleccion);

end loop;

case eleccion is

-- Insertar:

when 1 =>

if p.indice(pila) < max then

put("Inserte un numero de DNI: "); get(temp.num);

put("Insertar la letra del DNI: "); get(temp.car);

p.insertar(pila, temp);

else

put_line("La pila esta llena.");

end if;

-- Extraer:

when 2 =>

if p.indice(pila) > 0 then

p.extraer(pila, temp);

put("El DNI extraido: "); put(temp.num); put(temp.car); new_line;

else

put_line("La pila no tiene informacion.");

end if;

-- Leer:

when 3 =>

if p.indice(pila) > 0 then

temp := p.leer(pila);

put("El DNI leido: "); put(temp.num); put(temp.car); new_line;

else

put_line("La pila no tiene informacion.");

end if;

-- Salir:

when 0 => NULL;

when others => NULL;

end case;

new_line; new_line;

if eleccion /= 0 then

put_line("Operacion realizada, elija otra opcion del menu superior:");

end if;

end loop;

end if;

end ada8x01;

-- ESPECIFICACIÓN/DECLARACIÓN DE LA PILA ESTÁTICA

	-- PRECONDICIÓN:
	 -- La librería a la hora de ser usada en el programa principal, ha de ser llamada enviándole dos parámetros.
	 -- El primero de ellos es el número positivo (1..N), y el segundo un tipo de dato, pudiendo ser uno predefinido de Ada o personalizado por nosotros.
	 -- Una posible sentencia seria: "package p is new pila_estatica( max, miNodo );"

	-- POSCONDICIÓN:
	 -- La propia librería, en el fichero pila_estatica.adb, tiene en cuenta que no se puedan leer o escribir nodos por debajo de 1 o por encima de N.
	 -- Sin embargo no avisa con ningún tipo de alerta, simplemente no hace la operación ni se cierra el programa de forma inesperada.
	 -- Hay que usar la función "indice" que nos devuelve un parámetro entero con el índice actual, sabiendo eso podemos usar una condicional para controlar el rango a usar.



generic
	-- La librería al implementar un tipo abstracto de datos ha de recibir, desde generic, los parámetros que le pasamos al usar la librería. Por defecto se pasan y se definen en el mismo orden.
	max:positive;
	type miNodo is private;



package pila_estatica is

	-- Se define un tipo como privado y limitado:
	-- Private: Evita que se pueda acceder al contenido desde la implementación.
	-- limited: Además de lo anterior, evita que se puedan usar las operaciones ":=", "=" y "/=".
	type miPila is limited private;


	-- Se definen las cabeceras de las funciones contenidas en el fichero de implementación:
	function       indice( pila:in miPila ) return integer;
	function         leer( pila:in miPila ) return miNodo;
	procedure inicializar( pila:in out miPila );
	procedure    insertar( pila:in out miPila; nodo:in  miNodo );
	procedure     extraer( pila:in out miPila; nodo:out miNodo );


	-- Desde la zona privada, se detalla como son las variables declaradas previamente como privadas:
	private

		-- Se define el tipo miVector como un array de 1..MAX de tipo miNodo (que es privado asi que sera lo que hayamos detallado en el programa principal)
		type miVector is array (1..max) of miNodo;

		-- Definimos el tipi miPila, para las pilas, que es un registro con un elemento de tipo miVector, y un cima de tipo entero.
		type miPila is record
			elemento:miVector;
			cima:integer;
		end record;

end pila_estatica;

-- ESPECIFICACIÓN/DECLARACIÓN DE LA PILA ESTÁTICA

-- PRECONDICIÓN:

-- La librería a la hora de ser usada en el programa principal, ha de ser llamada enviándole dos parámetros.

-- El primero de ellos es el número positivo (1..N), y el segundo un tipo de dato, pudiendo ser uno predefinido de Ada o personalizado por nosotros.

-- Una posible sentencia seria: "package p is new pila_estatica( max, miNodo );"

-- POSCONDICIÓN:

-- La propia librería, en el fichero pila_estatica.adb, tiene en cuenta que no se puedan leer o escribir nodos por debajo de 1 o por encima de N.

-- Sin embargo no avisa con ningún tipo de alerta, simplemente no hace la operación ni se cierra el programa de forma inesperada.

-- Hay que usar la función "indice" que nos devuelve un parámetro entero con el índice actual, sabiendo eso podemos usar una condicional para controlar el rango a usar.

generic

-- La librería al implementar un tipo abstracto de datos ha de recibir, desde generic, los parámetros que le pasamos al usar la librería. Por defecto se pasan y se definen en el mismo orden.

max:positive;

type miNodo is private;

package pila_estatica is

-- Se define un tipo como privado y limitado:

-- Private: Evita que se pueda acceder al contenido desde la implementación.

-- limited: Además de lo anterior, evita que se puedan usar las operaciones ":=", "=" y "/=".

type miPila is limited private;

-- Se definen las cabeceras de las funciones contenidas en el fichero de implementación:

function indice( pila:in miPila ) return integer;

function leer( pila:in miPila ) return miNodo;

procedure inicializar( pila:in out miPila );

procedure insertar( pila:in out miPila; nodo:in miNodo );

procedure extraer( pila:in out miPila; nodo:out miNodo );

-- Desde la zona privada, se detalla como son las variables declaradas previamente como privadas:

private

-- Se define el tipo miVector como un array de 1..MAX de tipo miNodo (que es privado asi que sera lo que hayamos detallado en el programa principal)

type miVector is array (1..max) of miNodo;

-- Definimos el tipi miPila, para las pilas, que es un registro con un elemento de tipo miVector, y un cima de tipo entero.

type miPila is record

elemento:miVector;

cima:integer;

end record;

end pila_estatica;

-- IMPLEMENTACIÓN DE LA PILA ESTÁTICA


-- Funciones del paquete:
package body pila_estatica is


	-- Devuelve un entero de la posición en la que se esta en la Pila:
	function indice( pila:in miPila ) return integer is
	begin
		return pila.cima;
	end indice;


	-- Inicializa la pila poniendo la cima/índice a 0:
	procedure inicializar( pila:in out miPila ) is
	begin
		pila.cima := 0;
	end inicializar;


	-- Devuelve la información contenida en la cima de la Pila:
	function leer( pila:in miPila ) return miNodo is
	begin
		return pila.elemento(pila.cima);
	end leer;


	-- Inserta un nuevo nodo sobre la pila:
	procedure insertar( pila:in out miPila; nodo:in miNodo ) is
	begin
		if pila.cima < max then
			pila.cima := pila.cima + 1;
			pila.elemento(pila.cima) := nodo;
		end if;
	end insertar;


	-- Extrae el último nodo insertado:
	procedure extraer( pila:in out miPila; nodo:out miNodo ) is
	begin
		if pila.cima >= 1 then
			nodo := pila.elemento(pila.cima);
			pila.cima := pila.cima - 1;
		end if;
	end extraer;


end pila_estatica;

-- IMPLEMENTACIÓN DE LA PILA ESTÁTICA

-- Funciones del paquete:

package body pila_estatica is

-- Devuelve un entero de la posición en la que se esta en la Pila:

function indice( pila:in miPila ) return integer is

begin

return pila.cima;

end indice;

-- Inicializa la pila poniendo la cima/índice a 0:

procedure inicializar( pila:in out miPila ) is

begin

pila.cima := 0;

end inicializar;

-- Devuelve la información contenida en la cima de la Pila:

function leer( pila:in miPila ) return miNodo is

begin

return pila.elemento(pila.cima);

end leer;

-- Inserta un nuevo nodo sobre la pila:

procedure insertar( pila:in out miPila; nodo:in miNodo ) is

begin

if pila.cima < max then

pila.cima := pila.cima + 1;

pila.elemento(pila.cima) := nodo;

end if;

end insertar;

-- Extrae el último nodo insertado:

procedure extraer( pila:in out miPila; nodo:out miNodo ) is

begin

if pila.cima >= 1 then

nodo := pila.elemento(pila.cima);

pila.cima := pila.cima - 1;

end if;

end extraer;

end pila_estatica;

el blog de giltesa

8×01-02: Modulo genérico Pila estático con tipo abstracto de datos TAD

Related Posts

Escriba aquí su comentarioCancelar respuesta