[Código Fuente] Pila Dinámica

/*******************************/
// pila_dinamica.h
/********************************/

#ifndef _PILA_H
#define _PILA_H

class Pila
{
     private:
             bool Copiar(const Pila& p);
             void Pila::Vaciar();
             struct Nodo;
             typedef Nodo* Puntero;
            
             struct Nodo
             {
                    TipoDato info;
                    Puntero sig;
             };
             Puntero cima;
            
     public:
            Pila();
            Pila (const Pila&); /* COnstructor de copia que se ejecuta cada vez
             que se pasa un parametro a una funcion*/

             ~Pila ();
            typedef int TipoDato;
            const Pila& operator= (const Pila&);
            bool Apilar(TipoDato elemento);
            bool Desapilar();
            bool CimaPila(TipoDato &elemento);    
            bool PilaVacia();
       
};


#endif

/*********************/
// pila_dinamica.cpp
/*********************/

#include <iostream>
#include "pila.h"

using namespace std;

Pila::Pila()
{
           cima = NULL;              
}

Pila::Pila(const Pila& p)
{
if(!Copiar(p))
    cerr << "Error de memoria al copiar pila." << endl;
}

Pila::~Pila()
{
            Vaciar();
}


bool Pila::Copiar(const Pila& p)
{
    bool ok=true;
    Puntero p_aux, dup, fin;
  
    Vaciar();
    p_aux = p.cima;
          while( (p_aux != NULL) && ok)
          {
                 dup = new Nodo;
                 if (dup == NULL)
                    ok = false;
                 else

                  {
                 dup -> info = p_aux -> info;
                 dup -> sig = NULL;
                 if (cima == NULL) //Si Cima = NULL entonces es la primera copia del nodo.
                     cima = dup;
                 else
                      fin-> sig = dup;
                 fin = dup;
                 p_aux = p_aux->sig;
                 }
          }
}    

return ok;
   
   
}
void Pila::Vaciar()
{
    while(Desapilar());
    cima = NULL;
}

const Pila& Pila::operator= (const Pila& p)
{
     if(! Copiar(p))
    cerr << "Error de memoria al copiar pila." << endl;
  return (*this);
}


bool Pila::PilaVacia()
{
    return (cima == NULL);    
}

bool Pila::Apilar(TipoDato elemento)
{
    Puntero p;
    p= new Nodo; //Creamos un nuevo puntero
     p -> info = elemento; // Este le añadimos el valor pasado

     p -> sig = cima; // Y apuntamos cima apunta a siguiente
     cima = p;
   
}

bool Pila::Desapilar()
{
    bool ok;
   Puntero p_aux;
   p_aux = cima;
   if(cima == NULL)
           ok = false;
   else

        {
           cima = cima -> sig;
           delete p_aux;
           ok=true;
       }
   return ok;
   
   
}

bool Pila::CimaPila(TipoDato &elemento)
{
    bool ok=true;
    if(cima==NULL)
                  ok=false;
    else

         elemento = cima -> info;
       
        return ok;    
   
}