You are on page 1of 14

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J.

Albert)

11
11.1 Fundamentos

PILAS

En este tema y en el siguiente se analizarn las estructuras de datos lineales pilas y colas. Las pilas y las colas son dos de las estructuras de datos ms utilizadas. Se trata de dos casos particulares de las estructuras lineales generales (secuencias o listas) que, debido a su amplio mbito de aplicacin, conviene ser estudiadas de manera independiente. En este tema se estudiarn las pilas, su utilizacin y su implementacin ms habitual en !!. La pila es una lista de elementos caracterizada porque las operaciones de insercin y eliminacin de elementos se realizan solamente en un e"tremo de la estructura. El e"tremo donde se realizan estas operaciones se denomina habitualmente cima (top en la nomenclatura inglesa). #ada una pila P, $ormada por los elementos a, b, c, ..., k (P=(a,b,c,...,k)), se dice que a, que es el elemento ms inaccesible de la pila, est en el $ondo de la pila (bottom) y que %, por el contrario, el ms accesible, est en la cima ( top). Las restricciones de$inidas para la pila implican que si una serie de elementos A, B, C, D, E, F se a&aden, en este orden, a una pila entonces el primer elemento que se elimine (borre) de la estructura deber ser E. 'or tanto, resulta que el (ltimo elemento que se inserta en una pila es el primero que se borra. 'or esa razn, se dice que una pila es una lista o estructura lineal de tipo L)*+ (Last In First Out, el (ltimo que entra es el primero que sale). Estructura Pila A B C D E F ,orrado )nsercin -n e.emplo t/pico de pila lo constituye un montn de platos0 uando se quiere introducir un nuevo plato, 1ste se coloca en la posicin ms accesible, encima del (ltimo plato. uando se coge un plato, 1ste se e"trae, igualmente, del punto ms accesible, el (ltimo que se ha introducido. +, si somos ms estrictos, otro e.emplo ser/a una ca.a llena de libros. Las paredes de la ca.a impiden acceder libremente a su contenido y slo se puede acceder al libro que est ms arriba en la ca.a. 2l almacenar o e"traer un libro, slo es posible actuar sobre ese primer libro. 3o es posible siquiera saber el n(mero total de libros guardados en la pila. Slo se conocer el n(mero de elementos de la pila de libros si previamente los sacamos hasta vaciar la ca.a. +tro e.emplo natural de la aplicacin de la estructura pila aparece durante la e.ecucin de un programa de ordenador, en la $orma en que la mquina procesa las llamadas a las $unciones. ada llamada a una $uncin hace que el sistema almacene toda la in$ormacin asociada con esa $uncin (parmetros, variables, constantes, direccin de retorno, etc...) de $orma independiente a otras $unciones y permitiendo que unas $unciones puedan invocar a otras distintas (o a si mismas) y que toda esa in$ormacin almacenada pueda ser recuperada convenientemente cuando corresponda. omo durante la e.ecucin de un programa slo se
P !. "

Tema !. T"#os de datos

puede estar e.ecutando una $uncin (asumiendo que no e"iste e.ecucin concurrente dentro del programa), esto quiere decir que slo es necesario que sean accesibles los datos de la $uncin activa (la que est en la cima de llamadas). #e ah/ que una estructura muy apropiada para este $in sea la estructura pila. En general, una pila tiene su utilidad cuando interesa recuperar la (ltima in$ormacin generada (el estado inmediatamente anterior). 2sociadas con la estructura pila e"isten una serie de operaciones necesarias para su manipulacin. 4stas son0 )niciacin de la estructura0 5 rear la pila (CrearPila)0 La operacin de creacin de la pila inicia la pila como vac/a. +peraciones para a&adir y eliminar in$ormacin0 5 2&adir elementos en la cima (Apilar)0 pondr un nuevo elemento en la parte superior de la pila. 5 Eliminar elementos de la cima (Desapilar)0 lo que har ser eliminar el elemento superior de la pila. +peraciones para comprobar tanto la in$ormacin contenida en la pila, como el propio estado de la cima0 5 omprobar si la pila est vac/a (PilaVacia)0 Esta operacin es necesaria para veri$icar la e"istencia de elementos de la pila. 5 2cceder al elemento situado en la cima (CimaPila)0 #evuelve el valor del elemento situado en la parte superior de la pila. omo en el caso de cualquier contenedor de datos las operaciones relevantes tienen que ver con el almacenamiento (Apilar), eliminacin (Desapilar) o consulta (CimaPila) de in$ormacin. La especi$icacin correcta de todas estas operaciones permitir de$inir adecuadamente el tipo pila. -na declaracin ms $ormal de las operaciones de$inidas sobre la estructura de datos pila, y los a"iomas que las relacionan es la siguiente0 Estru$tura
Pila ( Valor ) /# Valor constitu$e el %ominio sobre el &ue se %e'ine el tipo %e %atos $ (ace re'erencia a los %atos &ue se almacenan en la pila #)

%#era$"ones
CrearPila () Pila Apilar (Pila , Valor) Pila Desapilar (Pila) Pila CimaPila (Pila) Valor PilaVacia (Pila) Lgico

A&"omas

s Pila, x Valor se cumple &ue* PilaVacia (CrearPila ()) cierto PilaVacia (Apilar (s, x)) falso

P !. +

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J. Albert)

Desapilar (CrearPila ()) error Desapilar (Apilar (s, x)) s CimaPila (CrearPila ()) error CimaPila (Apilar (s, x)) x

Estos a"iomas e"plican de manera precisa el comportamiento de las operaciones que caracterizan las pilas y constituyen la re$erencia en la que se debe basar cualquier implementacin de este tipo. Son el plano sobre el que basarse a la hora de la construccin.

11.2 Representacin de Pilas en C++


Los lengua.es de programacin de alto nivel no suelen disponer de un tipo de datos prede$inido pila. 'or lo tanto, es necesario representar la estructura pila a partir de otros tipos de datos e"istentes en el lengua.e. En !!, lo primero que se plantea al construir una clase que represente el tipo pila son los m1todos p(blicos a trav1s de los que se podr manipular la estructura. Las operaciones sern bsicamente las de$inidas en el tipo abstracto de datos, aunque ser preciso adaptarse a las caracter/sticas del lengua.e para establecer los detalles $inales de la representacin. 2s/, se puede establecer el siguiente inter$az para la clase pila0
class Pila { public: Pila (); bool Apilar (Valor); bool Desapilar (); bool CimaPila (Valor ); bool PilaVacia (); pri!ate: //"o#a!$a por #efi%ir &;

Los criterios establecidos para esta de$inicin son los siguientes0

2quellas operaciones que, seg(n el 62#, puedan generar un error (Desapilar, CimaPila) devolvern un valor lgico que indique si la operacin se ha realizado correctamente o no. La operacin CimaPila devuelve un valor lgico para in$ormar de un posible error, pero tambi1n debe retornar el valor que se ubica en la cima de la pila. omo no es posible que una $uncin devuelva dos valores di$erentes, se plantea que tenga un argumento por re$erencia que permita almacenar como salida de la operacin el valor almacenado en la cima de la pila. La operacin Apilar permitir a&adir nuevos elementos a la pila. 3o obstante, es posible que el espacio en memoria para los elementos de la pila est1 limitado (en principio, el l/mite puede ser la memoria disponible en el ordenador) y es posible que la pila se 7llene8 y no admita nuevos elementos. 4sto deber/a generar un error similar al generado cuando se desea eliminar un dato y la pila est vac/a. 'or ese motivo, se plantea que la operacin

P !. ,

Tema !. T"#os de datos

devuelva un valor lgico que in$orme sobre si la operacin se ha podido realizar correctamente.

9ecordar que en !!, si la implementacin se realiza mediante clases, no es necesario pasar como parmetro el ob.eto receptor de la peticin de operacin. Ese es un argumento impl/cito en todas las operaciones. *inalmente, el m1todo de iniciacin de la estructura CrearPila toma la $orma de lo que se conoce en !! como un constructor de ob.etos de la clase. El constructor es un m1todo especial que es llamado siempre que se instancia (declara) un nuevo ob.eto de una clase. Si no e"iste el constructor por de$ecto, la instanciacin se limita a reservar el espacio necesario para guardar la in$ormacin del ob.eto. Si e"iste el constructor por de$ecto, 1ste es llamado inmediatamente despu1s de la reserva de memoria y permite establecer un estado inicial correcto para el ob.eto. El constructor es un m1todo que tiene el mismo nombre que la clase, no devuelve ning(n valor (ni siquiera void) y puede tener los parmetros que se consideren oportunos, en nuestro caso ninguno (constructor por de$ecto).

11.2.1. Implementacin mediante estructuras estticas


La $orma ms simple, y habitual, de representar una pila es mediante un vector unidimensional. Este tipo de datos permite de$inir una secuencia de elementos (de cualquier tipo) y posee un e$iciente mecanismo de acceso a la in$ormacin contenida en ella. 2l de$inir un arra$ hay que determinar el n(mero de /ndices vlidos y, por lo tanto, el n(mero de componentes de$inidos. Entonces, la estructura pila representada por un array tendr limitado el n(mero de posibles elementos. La parte privada de la clase, que hace re$erencia a los detalles de implementacin seleccionados, estar constituida por un vector para almacenar los elementos de la pila. El primer elemento se almacenar en la posicin ' y ser el $ondo de la pila, el segundo elemento en la posicin ( y as/ sucesivamente. En general, el elemento i51simo estar almacenado en la posicin i)( del vector. omo todas las operaciones se realizan sobre la cima de la pila, es necesario tener correctamente localizada en todo instante esta posicin. Es necesaria una variable adicional, cima, que apunte al (ltimo elemento de la pila (no del array) o que indique cuntos elementos hay almacenados en ella. Sea una pila p cuyos elementos son (a, b, c, #, e), siendo e su cima. La representacin gr$ica de la implementacin de p mediante un array ser/a0
p : (a, b, c, #, e)

; a

< b

= c

> #

? e ...

@2A5<

cima
P !. -

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J. Albert)

Si se reescribe el inter$az de la clase pila para re$le.ar esta $orma de implementacin se tiene que0
class Pila { public: Pila (); bool Apilar (Valor); bool Desapilar (); bool CimaPila (Valor ); bool PilaVacia (); pri!ate: t*pe#ef Valor Vector+,A-.; Vector #atos; i%t cima; &;

Suponiendo Valor como el tipo de dato que se puede almacenar en la pila y ,A- una constante que limita el tama&o m"imo del array (y de la pila). on estas consideraciones prcticas, se puede pasar a construir las operaciones que de$inen la pila. %#era$"'n CrearPila La creacin de la pila se realizar mediante el constructor por de$ecto. La tarea que deber realizar ser establecer un estado inicial en el que no e"isten elementos en la pila0
Pila::Pila () { cima / )(; &

omo la primera posicin vlida del array es la identi$icada por el /ndice ;, con la asignacin cima : 5< se intenta representar que, si no hay elementos en la pila, la cima se encuentra una posicin antes de la primera posicin del vector y, por tanto, en una posicin no vlida del mismo. Esta operacin permitir que al declarar ob.etos de esta clase, en la $orma habitual en 1stos se inicialicen adecuadamente de $orma automtica. 'or e.emplo0 Pila p; %#era$"'n PilaVacia Esta operacin permitir determinar si la estructura tiene o no elementos almacenados. 2unque el array empleado tiene un n(mero de elementos $i.o (@2A), no todos ellos representan valores almacenados en la pila. Slo estn almacenados en la pila los valores comprendidos entre los /ndices ' ($ondo de la pila) y cima. 'or lo tanto, la pila estar vac/a cuando la cima indique una posicin por deba.o del $ondo0
bool Pila::PilaVacia () { retur% (cima // )();
P !. .

!!,

Tema !. T"#os de datos

&

%#era$"'n Apilar La operacin de insercin normalmente se conoce por su nombre ingl1s Pus(, o 2pilar. La operacin, aplicada sobre un pila y un valor, almacena el valor en la cima de la pila. Esta operacin est restringida por el tipo de representacin escogido. En este caso, la utilizacin de un array implica que se tiene un n(mero m"imo de posibles elementos en la pila, por lo tanto, es necesario comprobar, previamente a la insercin, que realmente hay espacio en la estructura para almacenar un nuevo elemento. on est consideracin, el algoritmo de insercin ser/a0
bool Pila::Apilar (Valor x) { bool o0; if (cima // ,A-) o0 / false; else { cima11; #atos+cima. / x; o0 / true; & retur% (o0); &

%#era$"'n Desapilar La operacin de borrado elimina de la estructura el elemento situado en la cima. 3ormalmente recibe el nombre de Pop en la bibliogra$/a inglesa. Eliminar un elemento de la pila consiste $undamentalmente en desplazar (decrementar) la cima. 'uesto que no es posible eliminar $/sicamente los elementos de un array, lo que se hace es de.ar $uera del rango vlido de elementos al primero de ellos.
bool Pila::Desapilar (!oi#) { bool o0; if (cima // )() o0 / false; else { cima)); o0 / true; & retur% (o0);

P !. /

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J. Albert)

&

%#era$"'n CimaPila La operacin de consulta permite conocer el elemento almacenado en la cima de la pila, teniendo en cuenta que si la pila est vac/a no es posible conocer este valor.
bool Pila::CimaPila (Valor { bool o0; if (cima // )() o0 / false; else { x / #atos+cima.; o0 / true; & retur% (o0); & x)

11.2.2. Implementacin mediante estructuras dinmicas


-no de los mayores problemas en la utilizacin de estructuras estticas (arrays), estriba en el hecho de tener que determinar, en el momento de la realizacin del programa, el valor m"imo de elementos que va a poder contener la estructura. Esto implica una estimacin que no siempre es posible o que no siempre es muy a.ustada a la realidad de una e.ecucin en particular. Esto implica un desaprovechamiento de la memoria y coste espacial ine$iciente de esta $orma de representacin. 'or e.emplo, si tama&o el array se de$ine con un atama&o <;; y slo hay =; elementos en la pila, el B;C del espacio reservado no se utiliza. -na posible solucin a este problema es la utilizacin de estructuras dinmicas enlazadas (punteros) tal y como se e"plic en el primer cuatrimestre del curso. En este caso, los elementos que constituirn la pila no estarn almacenados de manera consecutiva en memoria, como en un array, sino que se irn creando dinmicamente (durante la e.ecucin del programa) y se irn distribuyendo 7aleatoriamente8 en la memoria. 'ara que estos elementos dispersos puedan $ormar una secuencia es preciso que est1n relacionados o enlazados entre s/. Lo que permite el tipo puntero es establecer estos enlaces entre los elementos. #e manera que un elemento (o nodo) de la pila no estar $ormado e"clusivamente por un elemento del tipo Dalor, sino que se tratar de un dato compuesto que incluir adicionalmente un puntero para enlazar con el siguiente elemento de la secuencia. Er$icamente, una pila p cuyos elementos son (a, b, c, #, e), siendo e su cima, se representar/a de manera enlazada de la siguiente $orma0
p : (a, b, c, #, e)

P !. 0

Tema !. T"#os de datos

cima

on esta $orma de implementacin, el inter$az de la clase 'ila quedar/a como sigue0


class Pila { public: Pila (); bool Apilar (Valor); bool Desapilar (); bool CimaPila (Valor ); bool PilaVacia (); pri!ate: struct 2o#o; t*pe#ef 2o#o3 Pu%tero; struct 2o#o { Valor i%fo; Pu%tero sig; &; Pu%tero cima; &;

omo se puede observar, se ha modi$icado la parte privado de la clase, pero sus elementos p(blicos. La idea es que la $orma de utilizar una pila es la misma siempre, con independencia de como est1 construida. 2hora el (nico dato de$inido en la clase es un puntero (cima) que permite acceder al elemento situado en la cima de la pila y a partir de 1l, siguiendo el enlace sig de cada nodo, es posible acceder al resto de los elementos. Los elementos de la pila no estn declarados en la clase puesto que se irn creando a medida que se vayan a&adiendo a la misma. 2hora la implementacin de cada una de las operaciones queda como sigue0 %#era$"'n CrearPila Slo es preciso indicar que inicialmente el puntero cima no hace re$erencia a ning(n nodo, puesto que la pila se crea vac/a.
Pila::Pila () {
P !. 1

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J. Albert)

cima / 24LL; &

%#era$"'n PilaVacia 3ecesita veri$icar si el puntero a cima re$erencia alg(n nodo.


bool Pila::PilaVacia () { retur% (cima // 24LL); &

%#era$"'n Apilar 2hora es preciso reservar memoria para cada nuevo elemento que se desee apilar, puesto que no hay espacio reservado para 1l a priori. 2dems de 1sto, es preciso que el nuevo elemento se enlace adecuadamente con el resto de elementos de la pila. 'ara ello, el proceso a realizar consta de los siguientes pasos0 <) 9eservar memoria para un nuevo nodo de la pila. =) Establecer los valores adecuados para los campos del nodo0 =.<) El campo de in$ormacin ser igual al valor que se desea apilar. =.=) El campo siguiente har re$erencia a la cima actual de la pila, puesto que el nuevo elemento se debe situar delante de ella. >) omo el nuevo nodo es la nueva cima de la pila, es preciso actualizar el puntero cima para apunte al nuevo nodo.
bool Pila::Apilar (Valor x) { bool o0; Pu%tero p5aux; p5aux / %e6 2o#o; //Paso ( if (p5aux // 24LL) o0 / false; else { p5aux)7i%fo / x; //Paso 89( p5aux)7sig / cima; //Paso 898 cima / p5aux; //Paso : o0 / true; & retur% (o0); &
P !. 2

Tema !. T"#os de datos

%#era$"'n Desapilar En una estructura dinmica es posible liberar la memoria reservada previamente si ya nos es necesaria. En este caso, cuando se desapila un elemento, es posible liberar la memoria asociado al nodo que ocupa en la pila. Luego, adems de avanzar la cima para que el elemento quede $uera de la pila se debe liberar la memoria que ocupaba. La $uncin ser/a la siguiente0
bool Pila::Desapilar (!oi#) { bool o0; Pu%tero p5aux; if (cima // 24LL) o0 / false; else { p5aux / cima; cima / cima)7sig; //a!a%;ar cima #elete p5aux; //liberar la memoria (borrar %o#o) o0 / true; & retur% (o0); &

%#era$"'n CimaPila Esta operacin debe devolver el valor almacenado en la pila de la cima. En este caso, la in$ormacin almacenada en el campo i%fo del nodo situado en la cima (no todo el nodo).
bool Pila::CimaPila (Valor { bool o0; if (cima // 24LL) o0 / false; else { x / cima)7i%fo; o0 / true; & retur% (o0); & x)

.(.) *lases y #unteros en *++


P !. "3

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J. Albert)

2l programar con punteros hay que tener en cuenta aspectos irrelevantes cuando se utilizan estructuras estticas. En particular, el problema de la copia o de la eliminacin de las estructuras creadas. Fay que considerar, por e.emplo, que cuando se pasa un argumento por valor a una $uncin, lo que se est haciendo es crear una copia del dato que se pasa en la llamada. 'or e.emplo, sea el siguiente prototipo de $uncin, !oi# f (Pila s), y sea f (p), donde p es un ob.eto de tipo Pila, una llamada a la $uncin f. Lo que se est haciendo en la llamada, al asociar el argumento s a p, es generar s como una copia e"acta de p. Eso implica copiar el contenido de los datos declarados en la clase a la que pertenece el ob.eto, en este caso Pila. omo el (nico dato especi$icado en la clase es el puntero cima, lo que en realidad se est haciendo es asignar a s9cima el valor de p9cima. 'or tanto, en realidad s y p comparten los mismos datos y no se est haciendo un duplicado real de la pila. Este es un problema que se reproduce siempre que se mane.an clases con punteros. En !! es posible indicar cmo se debe hacer de manera correcta la copia de ob.etos. La solucin consiste en de$inir en la clase un tipo especial de constructor, llamado constructor de copia, que debe especi$icar la $orma correcta en la que se debe generar un duplicado del ob.eto. ada vez que el lengua.e requiera crear un nuevo ob.eto como copia de otro (paso de argumentos por valor, valores de retorno de una $uncin, variables temporales) buscar el constructor de copia y si est de$inido e.ecutar el algoritmo de copia especi$icado en 1l. El constructor de copia no se suele invocar de manera e"pl/cita por parte del programador y su uso est un tanto oculto durante la e.ecucin del programa. Sin embargo, su ausencia puede provocar que los programas no $uncionen correctamente. *onstru$tor de $o#"a #ara la $lase P"la El constructor de copia tiene el mismo nombre que la clase y tiene como argumento argumento un ob.eto de la misma clase pasado por re$erencia (si $uese por valor se tendr/a un bucle recursivo in$inito) pero 7protegido8 con el cali$icativo co%st, para que no se pueda modi$icar. En el caso que nos ocupa, suponiendo que e"iste una $uncin au"iliar que realiza la copia e$ectiva de las pilas, lo que permite utilizarla desde cualquier otro m1todo, el constructor de copia tendr/a la siguiente $orma0
Pila::Pila (co%st Pila p) { if (< Copiar(p)) cerr == >?rror #e memoria al copiar pila9> == e%#l; &

La $uncin opiar realiza el duplicado del original sobre el ob.eto destino de la copia (receptor de la peticin). Los pasos que realiza son0 <) Daciar la pila sobre la que se va a copiar. Esto permite una aplicacin ms general de esta $uncin, incluso para realizar asignaciones de ob.etos. =) 9ecorrer uno a uno todos los elementos de la pila original y generar una copia de cada elemento en la pila destino.
bool Pila::Copiar (co%st Pila { Pu%tero p5aux, #up, fi%; bool o0/true; p)

P !. ""

Tema !. T"#os de datos

Vaciar(); //fu%ci% @ue se especifica mAs a#ela%te p5aux / p9cima; 6Bile ( (p5aux </ 24LL) o0 ) { #up / %e6 2o#o; if (#up // 24LL) o0 / false; else { #up)7i%fo / p5aux)7i%fo; #up)7sig / 24LL; if (cima // 24LL) cima / #up; else fi%)7sig / #up; fi% / #up; p5aux / p5aux)7sig; & & retur% (o0); & !oi# Pila::Vaciar() { 6Bile (Desapilar()); &

%#erador as"gna$"'n El operador asignacin tiene el mismo problema que la copia de ob.etos cuando se mane.an punteros. Se trata tambi1n de copiar un ob.eto en otro. 'ara que se pueda utilizar de manera correcta el operador asignacin sobre elementos de la clase pila implementada con punteros es preciso realizar lo que se llama una sobrecar!a del operador asignacin (/). Esto signi$ica especi$icar cmo se debe realizar la asignacin de ob.etos de esta clase. La posibilidad de ampliar el $uncionamiento de los operadores estndar del lengua.e para nuevos tipos de datos es una caracter/stica espec/$ica de !! que no posee otros lengua.es de programacin. La implementacin de la sobrecarga del operador / (operator/) ser/a id1ntica a la del operador de copia (de ah/ la conveniencia de haber de$inido la $uncin Copiar).
co%st Pila Pila::operator/ (co%st Pila p) { if (< Copiar(p)) cerr == >?rror #e memoria al copiar pila9> == e%#l; retur% (3tBis);
P !. "+

Alg. y Estr. Datos-I / Fund. Progr.-II (R. Ferrs, J. Albert)

&

Esto permite utilizar el operador : de manera natural sobre pilas. 'or e.emplo,
Pila p, @; p / @;

2 la hora de implementar la sobrecarga de cualquier operador se debe tener en cuenta que0 <) El nombre del operador es siempre la palabra operator seguida del s/mbolo(s) que identi$ica al operador. =) El n(mero de argumentos del operador sobrecargado debe coincidir con los del operador original. En el caso del operador asignacin, se tiene un argumento del tipo pila (representa a la pila a la derecha de la asignacin, ya que el ob.eto receptor de la operacin es el que se sit(a a la izquierda del operador y est impl/cito en la $uncin) y el valor de retorno es tambi1n una pila (por re$erencia constante), de igual manera que se de$ine habitualmente el operador. Destru$tor El problema inverso a la copia de pilas se tiene cuando se debe liberar la memoria de las pilas (destruir). En !! todos los ob.etos y variables de$inidas tiene un mbito de declaracin. 6iene un periodo de 7vida8. *uera de ese mbito los ob.etos de.an de e"istir, se destruyen. Eso implica la liberacin de la memoria que ocupan. Sin embargo, cuando se mane.an pilas con punteros el (nico espacio que se libera es (de nuevo) el ocupado por la variable cima. @ientras que los nodos creados para la pila permanecen en la memoria, ocupando un espacio que no se puede liberar. En !!, la solucin es de$inir un destructor, cuya misin es inversa a la del constructor. Se trata de especi$icar que debe se debe de hacer antes de liberar la memoria del ob.eto. En nuestro, liberar antes la memoria ocupada por los nodos. El destructor de una clase es (nico, a di$erencia del constructor, y no tiene argumentos. Su nombre es el mismo de la clase, pero precedido del s/mbolo G. Suponiendo que e"iste la $uncin au"iliar Vaciar que se ha utilizado ya en la $uncin Copiar, el destructor de la clase Pila tendr/a la siguiente $orma0
Pila::CPila () { Vaciar(); &

Si se reescribe el inter$az de la clase Pila para re$le.ar todas las operaciones introducidas se tiene que0
class Pila { public: Pila (); Pila (co%st Pila ); CPila (); co%st Pila operator/ (co%st Pila ); bool Apilar (Valor);
P !. ",

Tema !. T"#os de datos

bool Desapilar (); bool CimaPila (Valor ); bool PilaVacia (); pri!ate: struct 2o#o; t*pe#ef 2o#o3 Pu%tero; struct 2o#o { Valor i%fo; Pu%tero sig; &; Pu%tero cima; !oi# Vaciar(); bool Copiar (co%st Pila ); &;

Las operaciones opiar y Daciar se han declarado como operaciones privadas, puesto que se trata de operaciones au"iliares que ayudan a construir otras operaciones pero que no se plantea que puedan ser utilizadas desde $uera de la clase.

P !. "-