• Sábado 14 de Diciembre de 2024, 18:03
« anterior próximo »
Páginas: [1]

Autor Tema:  Clase De Pila Con Templates  (Leído 1030 veces)

redonmax

  • Nuevo Miembro
  • *
  • Mensajes: 5
    • Ver Perfil
Clase De Pila Con Templates
« en: Jueves 12 de Enero de 2006, 20:26 »
0
Hola, he ehcho la siguiente clase con templates:
Código: Text
  1. #include <_vector.h>
  2. #include <_llist.h>
  3. #include <iostream>
  4. #include <cstdlib>
  5. using namespace std;
  6.  
  7. template <class T>
  8. class baseStack {
  9. public:
  10.   virtual void  clear  () = 0;
  11.   /* Modifica: la pila receptora que pasa a estar vacía. */
  12.   virtual bool  empty  () const = 0;
  13.   /* Produce:  cierto si la pila receptora es vacía.   */
  14.   virtual T      top    () const = 0;
  15.   /* Produce:  el elemento del tope de la pila.
  16.      Error:    si la pila está vacía.                */
  17.   virtual void  push    (const T & value) = 0;
  18.   /* Necesita: un valor de tipo T.
  19.      Modifica: la pila receptora añadiendo el valor
  20.          indicado al tope de la pila.    */
  21.   virtual void  pop    () = 0;
  22.   /* Modifica: la pila receptora suprimiendo el elemento
  23.                situado en el tope de la pila.
  24.      Error:    si la pila está vacía.                    */
  25. };
  26.  
  27.  
  28. //---------------------------------------------------------------------------
  29. //                                                
  30. //         Definicion de la clase VStack
  31. //                  Pilas basadas en vectores            
  32. //                                              
  33. //---------------------------------------------------------------------------
  34.  
  35. //
  36. // Clase VStack
  37. //  Implementacion de pilas utilizando vectores
  38. //
  39.  
  40. template <class T>
  41. class VStack : public baseStack<T> {
  42. public:
  43.   // constructores
  44.   explicit VStack  (int size=0);
  45.   VStack          (const VStack<T> & rhs);
  46.  
  47.   // operaciones para pilas
  48.   virtual void   clear  ();
  49.   /* Coste t.: O(1)    */
  50.   virtual bool   empty  () const;
  51.   /* Coste t.: O(1)    */
  52.   virtual T  top    () const;
  53.   /* Coste t.: O(1)    */
  54.   virtual void  push  (const T & value);
  55.   /* Coste t.: O(1), O(n) si se redimensiona.  */
  56.   virtual void  pop    ();
  57.   /* Coste t.: O(1)    */
  58.    
  59.   // asignacion
  60.   VStack<T> & operator =  (const VStack<T> & rhs);
  61.  
  62.   //operaciones adicionales
  63.   int size () const;
  64.   // Produce:  el numero de elementos de la lista.
  65.   // Coste t.: O(1)
  66.    
  67. protected:
  68.   // area de datos
  69.   sVector<T>  data;
  70.   int  theTop;      // posicion del tope de la pila
  71.  
  72.   //operaciones privadas para el control de errores
  73.   void assertIsEmpty() const;  
  74. };
  75. template <class T>
  76. VStack<T>::VStack
  77.   (int size) : data(size), theTop(-1)
  78. {
  79.   // crea e inicializa una pila
  80. }
  81.  
  82. template <class T>
  83. VStack<T>::VStack (const VStack<T> & rhs)
  84.   : data(rhs.data), theTop(rhs.theTop)
  85. {
  86.   // constructor de copia
  87. }
  88.  
  89. template <class T>
  90. void VStack<T>::clear ()
  91. {
  92.   // borra los elementos de una pila
  93.   theTop = -1;
  94. }
  95.  
  96. template <class T>
  97. bool VStack<T>::empty () const
  98. {
  99.   // retorna cierto si la pila no tiene elementos
  100.   return theTop == -1;
  101. }
  102.  
  103. template <class T>
  104. T VStack<T>::top () const
  105. {
  106.   // retorna el elemento del tope de la pila
  107.   assertIsEmpty();
  108.   return data[theTop];
  109. }
  110.  
  111. template <class T>
  112. void VStack<T>::push (const T & value)
  113. {
  114.   // inserta un elemento en la pila
  115.   // si la pila está llena, aumentarla
  116.   if (theTop == data.size()-1)
  117.     data.resize(data.size()*2+1);
  118.  
  119.   data[++theTop] = value;
  120. }
  121.  
  122. template <class T>
  123. void VStack<T>::pop ()
  124. {
  125.   // borra el elemento del tope de la pila
  126.   assertIsEmpty();
  127.   theTop--;
  128. }
  129.  
  130. template <class T>
  131. VStack<T> & VStack<T>::operator = (const VStack<T> & rhs)
  132. {
  133.   // asignacion
  134.   if( this != &rhs )
  135.   {
  136.     data = rhs.data;
  137.     theTop = rhs.theTop;
  138.   }  
  139.   return *this;
  140. }
  141.  
  142. template <class T>
  143. int VStack<T>::size () const
  144. {
  145.    return theTop+1;
  146. }
  147.  
  148. template <class T>
  149. void VStack<T>::assertIsEmpty( ) const
  150. {
  151.   if ( empty() )
  152.      throw runtime_error("VStack UnderFlow")&#59;
  153. }    
  154. int main() {
  155. VStack<int> v1;
  156. system("PAUSE");
  157. return 0;
  158. }
  159.  
  160.  

Y a la hora de porbar me da un monton de errores en la compilacion, alguien me puede echar una mano, estoy muy verde en templates.
Un saludo
Páginas: [1]
« anterior próximo »