Programación 2 - Web del Profesor

Programación 2
Universidad de Los Andes
Escuela de Ingeniería de Sistemas
Departamento de Computación
Programación OxO. TAD Pila,
implementación dinámica
TAD Pila
Implementación:
● Estática
● Paramétrica
Contenedor
tope
30/09/16
S. Solé - Programación 2
2
Pila – Implementación
Paramétrica
Una plantilla es un “patrón” que usa el compilador para
generar una familia de clases o funciones.
Para que el compilador genere el código, debe ver
tanto la definición de la plantilla (no sólo la declaración)
como los tipos específicos que se usan para llenar la
plantilla.
Si usa Pila<int> el compilador debe ver tanto la
plantilla de Pila como la creación de Pila<int>.
30/09/16
S. Solé - Programación 2
3
Pila – Implementación
Paramétrica
La forma más conveniente de usar las plantillas es colocando todas las
definiciones de funciones en el archivo de cabecera.
Cuando se instancia una plantilla, el compilador crea una nueva clase con el
argumento de plantilla que se ha dado. Pila<int> torrelibros;
Cuando el compilador lee esta línea crea una clase nueva, llamemosla
PilaInt, por lo que necesita tener acceso a la implementación de los métodos,
para instanciarlos con el argumento del template (en este caso entero). Si
estas implementaciones no están en el archivo de cabecera no se podrían
acceder a ellas y el compilador no podría instanciar la plantilla.
Otra solución es escribir la declaración de la plantilla en un archivo de
cabecera (.h), y luego implementar la clase en un archivo de implementación
(.tpp), que se incluye al final del archivo de cabecera.
30/09/16
S. Solé - Programación 2
4
class NodoS {
float dato;
NodoS *prox;
public:
NodoS() {
this->prox = 0;
}
NodoS* siguiente() const {
return this->prox;
}
float verDato() {
return this->dato;
}
float asignarDato(float d){
return (this->dato = d);
}
NodoS* siguiente( NodoS* ptr ) {
return ( this->prox = ptr ) ;
}
};
30/09/16
S. Solé - Programación 2
Nodo
Nodo Simple
5
Pila dinámica
tope
30/09/16
S. Solé - Programación 2
6
Pila.h
class Pila {
NodoS* tope; /// Tope de la pila
public:
Pila();
Pila(const Pila&);
~Pila();
int meteEnPila(float);
int sacarDePila();
float verTope() const;
bool estaVacia() const;
void operator=(const Pila&);
};
30/09/16
S. Solé - Programación 2
7
Insertar (Push)
tope
30/09/16
S. Solé - Programación 2
8
Insertar (Push)
tope
A
30/09/16
S. Solé - Programación 2
9
Insertar (Push)
tope
A
30/09/16
S. Solé - Programación 2
10
Insertar (Push)
B
tope
A
30/09/16
S. Solé - Programación 2
11
Insertar (Push)
tope
B
A
30/09/16
S. Solé - Programación 2
12
Extraer (Pop)
tope
aux
B
A
30/09/16
S. Solé - Programación 2
13
Extraer (Pop)
aux
B
tope
A
30/09/16
S. Solé - Programación 2
14
Extraer (Pop)
tope
A
30/09/16
S. Solé - Programación 2
15
Pila.cpp
Pila::Pila() {
this->tope = 0;
return;
}
Pila::~Pila() {
while( !this->sacarDePila() );
return;
}
30/09/16
S. Solé - Programación 2
16
Pila.cpp
int Pila::meteEnPila(float d){
NodoS* nodo = new NodoS;
if (nodo == 0 )
return 1;
nodo->asignarDato(d);
nodo->siguiente(this->tope);
this->tope = nodo;
return(0);
}
30/09/16
S. Solé - Programación 2
17
Pila.cpp
int Pila::sacarDePila() {
if (this->estaVacia())
return(1);
NodoS* aux = this->tope;
this->tope = aux->siguiente();
delete aux;
return(0);
}
30/09/16
S. Solé - Programación 2
18
Pila.cpp
float Pila::verTope() const {
return(this->tope->verDato());
}
bool Pila::estaVacia() const {
return(this->tope == 0);
}
30/09/16
S. Solé - Programación 2
19
Pila.cpp
Pila::Pila(const Pila& p) {
NodoS* aux1= p.tope;
NodoS* aux2;
NodoS* aux3;
if (aux1) {
NodoS* aux2 = this->tope = new NodoS;
assert(aux2);
do {
aux2->asignarDato(aux1->verDato());
if ( aux1 = aux1->siguiente() ) {
aux3 = new NodoS;
assert(aux3);
aux2->siguiente(aux3);
assert((aux2 = aux2->siguiente()) != 0);
}
}while(aux1);
} else
30/09/16 tope = 0;
S. Solé - Programación 2
}
20
void Pila::operator=(const Pila& p) {
while(!this->sacarDePila());
Pila.cpp
NodoS* aux1= p.tope;
if (aux1) {
NodoS* aux3;
NodoS* aux2 = this->tope = new NodoS;
assert(aux2);
do {
aux2->asignarDato(aux1->verDato());
if ( aux1 = aux1->siguiente() ) {
aux3 = new NodoS;
assert(aux3);
aux2->siguiente(aux3);
assert( (aux2 = aux2->siguiente()) != 0);
}
}while(aux1);
} else
this->tope = 0;
return;
30/09/16
}
S. Solé - Programación 2
21
Tarea #5
Simular el juego de las Torres
de Hanoi
30/09/16
S. Solé - Programación 2
22
Tarea #5
Objetivo del juego:
●
El objetivo del juego es mover los discos de la torre 1 a
la torre 3, usando la torre 2 como auxiliar. El resultado
final debe ser como sigue:
Reglas del juego:
● Sólo se puede mover una pieza cada vez; y para
agarrar una segunda pieza debemos de haber dejado
primero la anterior en alguna torre. Además una pieza
sólo puede apilarse encima de una más grande.
30/09/16
S. Solé - Programación 2
23
Tarea #5
Reglas del juego:
● En este juego siempre se tienen 3 torres y “n” fichas
(el valor de n se le solicitará al usuario) de tamaño
creciente, ordenadas en la primera torre por su
tamaño.
● El juego termina cuando las torres 1 y 2 estén
vacías y todas las fichas se encuentren en la
configuración correcta, mostrando el número de
jugadas realizadas y el número mínimo de jugadas
(2n–1) en el que se podría haber realizado.
30/09/16
S. Solé - Programación 2
24
Tarea #5
Requisitos del programa:
● Debe implementar el juego con la estructura de datos
Pila.
● Los discos se representarán mediante números enteros.
Los discos más grandes utilizarán valores enteros
mayores y los discos más pequeños utilizarán enteros
menores.
● El programa debe permitir decidir al jugador cuál es el
movimiento que desea realizar, indicando si es o no
posible.
● El programa debe mostrar por pantalla el estado inicial
del juego (todas las piezas colocadas en la torre 1 y las
torres 2 y 3 vacías).
30/09/16
S. Solé - Programación 2
25
Tarea #5
Requisitos del programa:
Después de mostrar el estado inicial del juego, debe
pedir sucesivamente pares de números indicando la
torre origen desde la que agarra la pieza y la torre
destino a la que el usuario quiere realizar el movimiento.
El programa analizará si la jugada es factible. Si el
resultado del análisis es positivo moverá la ficha de una
torre a otra. Si no lo es, indicará que es una jugada
imposible, indicando el por qué y pedirá un nuevo
movimiento.
● Después de cada jugada se mostrará el contenido de
las tres torres.
●
30/09/16
S. Solé - Programación 2
26
Tarea #5
●
●
Entrega hasta el 5/10/16 (max. 12 de la noche). Por
correo electrónico con asunto:
[PR2]Tarea5 - NOMBREYAPELLIDOS
Deben entregar los archivos de implementación de la
clase Pila (.h y .cpp), el programa que simula el juego
(.cpp) y el Makefile
Defensa de la tarea 6 de octubre 2016 de 8:30am a
11am.
● Si no se defiende la tarea no será evaluada.
●
30/09/16
S. Solé - Programación 2
27