• Sábado 9 de Noviembre de 2024, 03:29
« anterior próximo »
Páginas: [1]

Autor Tema:  Sobrecarga de << con template  (Leído 1993 veces)

Checho360

  • Miembro activo
  • **
  • Mensajes: 84
    • Ver Perfil
Sobrecarga de << con template
« en: Viernes 12 de Agosto de 2011, 16:19 »
0
Hola, estoy creando una clase pila y de momento iba todo bien, pero cuando me he puesto a sobrecargar el operador <<... no encuentro solución. Estuve mirando un rato por google y hay algo de información pero no entiendo muy bien... Aver si alguien me puede ayudar. Dejo el código para que se vean bien los errores al compilar:

Código: C++
  1. #include <iostream>
  2. #include <new>
  3. using namespace std;
  4.  
  5. template< class T >
  6. class PILA_DATOS{
  7.       template< class t > friend class PILA;
  8.       private:
  9.               T nodo;
  10.               PILA_DATOS< T > *ptrPilaSiguiente;
  11.              
  12. };
  13.  
  14. template< class T >
  15. class PILA{
  16.       friend ostream &operator<< <T>( ostream &, const PILA< T > & );
  17.       public:
  18.              PILA();
  19.              PILA< T > &empujarPila ( const T& );
  20.              PILA< T > &sacarPila ();
  21.       private:
  22.               PILA_DATOS< T > *ptrPila;
  23.               bool estaVacia ();
  24.              
  25. };
  26.  
  27. template< class T >
  28. PILA< T >::PILA (){
  29.      
  30.       ptrPila = NULL;
  31.      
  32. }
  33.  
  34. template< class T >
  35. bool PILA< T >::estaVacia (){
  36.      
  37.      return ( ptrPila == NULL ? true : false );
  38.      
  39. }
  40.  
  41. template< class T >
  42. PILA< T > &PILA< T >::empujarPila ( const T &a ){
  43.        
  44.         if ( estaVacia () ){
  45.              
  46.              ptrPila = new PILA_DATOS< T >;
  47.              ptrPila->nodo = a;
  48.              ptrPila->ptrPilaSiguiente = NULL;
  49.              
  50.         }
  51.        
  52.         else{
  53.              
  54.              PILA_DATOS< T > *nuevaPila;
  55.              nuevaPila= new PILA_DATOS< T >;
  56.              nuevaPila->nodo = a;
  57.              nuevaPila->ptrPilaSiguiente = ptrPila;
  58.              ptrPila = nuevaPila;
  59.              
  60.         }
  61.        
  62.         return *this;
  63.        
  64. }
  65.  
  66. template< class T >
  67. PILA< T > &PILA< T >::sacarPila (){
  68.      
  69.       PILA_DATOS< T > *temp;
  70.       temp = ptrPila;
  71.       ptrPila = ptrPila->ptrPilaSiguiente;
  72.       delete temp;
  73.       return *this;
  74.      
  75. }
  76.  
  77. template< class T >
  78. ostream &operator<<( ostream &salida, const PILA< T > &pila ){
  79.        
  80.         PILA_DATOS< T > *a = pila.ptrPila;
  81.         while ( a != NULL ){
  82.              
  83.               salida << a->nodo << "->";
  84.               a = a->ptrPilaSiguiente;
  85.              
  86.         }
  87.         salida << "NULL\n";
  88.         return salida;
  89.        
  90. }
  91.  
  92. int main (){
  93.    
  94.     PILA< int > a;
  95.     a.empujarPila (2).empujarPila (3).empujarPila(23).empujarPila (25);
  96.     cout << a;
  97.     a.sacarPila().sacarPila();
  98.     cout << a;
  99.    
  100.     getchar();
  101.    
  102.     return 0;
  103.    
  104. }
  105.  

Muchas gracias!

Geo

  • Miembro de PLATA
  • *****
  • Mensajes: 1011
  • Nacionalidad: mx
    • Ver Perfil
    • http://hsblog.mexchip.com
Re:Sobrecarga de << con template
« Respuesta #1 en: Domingo 14 de Agosto de 2011, 08:35 »
0
¿Y cuáles son los errores al compilar?

El error que veo es que intentas acceder al miembro privado nodo de PILA_DATOS cuando no le es permitido hacerlo a tu operador sobrecargado, para solucionarlo, algunas opciones:
  • Declara la función del operador como amiga de la clase PILA_DATOS, no solo de PILA.
  • Crea una función pública (get/obtener) que te permita acceder a la variable miembro nodo.
  • Declara nodo como variable pública ;).
La imaginación es el límite.
Hardware & Software | Mexchip

Checho360

  • Miembro activo
  • **
  • Mensajes: 84
    • Ver Perfil
Re:Sobrecarga de << con template
« Respuesta #2 en: Domingo 14 de Agosto de 2011, 13:17 »
0
Si, ya lo hice jeje. Lo resolvi sobrecargando tambien el operador << en PILA_DATOS, asi cuando recibia el operador << con un elemento de PILA este hace

cout << *ptrPila;

y asi llama al de PILA_DATOS y este ya puede acceder. Mira:

Código: C++
  1. #include <iostream>
  2. #include <new>
  3. using namespace std;
  4.  
  5. template< class T >
  6. class PILA_DATOS{
  7.       template< class t > friend class PILA;
  8.      
  9.       public:
  10.              template< class U > friend ostream& operator<< ( ostream &,
  11.              const PILA_DATOS< U > & );
  12.              PILA_DATOS< T > &operator= ( PILA_DATOS< T > & );
  13.       private:
  14.               T nodo;
  15.               PILA_DATOS< T > *ptrPilaSiguiente;
  16.              
  17. };
  18.  
  19. template< class U > ostream& operator<< ( ostream &salida,
  20. const PILA_DATOS< U > &a ){
  21.      
  22.       salida << a.nodo << "->";
  23.       PILA_DATOS< U > *b = a.ptrPilaSiguiente;
  24.       while ( b != NULL ){
  25.             salida << b->nodo << "->";
  26.             b = b->ptrPilaSiguiente;
  27.       }
  28.       salida << "NULL" << endl;
  29.       return salida;
  30.      
  31. }
  32. template< class T >
  33. PILA_DATOS< T >& PILA_DATOS< T >::operator= ( PILA_DATOS< T > &a ){
  34.            
  35.             nodo = a.nodo;
  36.             ptrPilaSiguiente = a.ptrPilaSiguiente;
  37.             return *this;
  38.            
  39. }      
  40.  
  41. template< class T >
  42. class PILA{
  43.       public:
  44.              PILA ();
  45.              ~PILA ();
  46.              PILA< T > &empujarPila ( const T& );
  47.              PILA< T > &sacarPila ();
  48.              PILA< T > &mostrarPila ();
  49.              template< class U > friend ostream& operator<< ( ostream &,
  50.              const PILA< U > & );
  51.       private:
  52.               PILA_DATOS< T > *ptrPila;
  53.               bool estaVacia ();
  54.              
  55. };
  56.  
  57. template< class T >
  58. PILA< T >::PILA (){
  59.      
  60.       ptrPila = NULL;
  61.      
  62. }
  63.  
  64. template< class T >
  65. PILA< T >::~PILA (){
  66.      
  67.       while ( ptrPila != NULL ){
  68.             PILA_DATOS< T > *temp = ptrPila;
  69.             ptrPila = ptrPila->ptrPilaSiguiente;
  70.             delete temp;
  71.       }
  72.      
  73. }
  74.  
  75. template< class T >
  76. bool PILA< T >::estaVacia (){
  77.      
  78.      return ( ptrPila == NULL ? true : false );
  79.      
  80. }
  81.  
  82. template< class T >
  83. PILA< T > &PILA< T >::empujarPila ( const T &a ){
  84.        
  85.         if ( estaVacia () ){
  86.              
  87.              ptrPila = new PILA_DATOS< T >;
  88.              ptrPila->nodo = a;
  89.              ptrPila->ptrPilaSiguiente = NULL;
  90.              
  91.         }
  92.        
  93.         else{
  94.              
  95.              PILA_DATOS< T > *nuevaPila;
  96.              nuevaPila= new PILA_DATOS< T >;
  97.              nuevaPila->nodo = a;
  98.              nuevaPila->ptrPilaSiguiente = ptrPila;
  99.              ptrPila = nuevaPila;
  100.              
  101.         }
  102.        
  103.         return *this;
  104.        
  105. }
  106.  
  107. template< class T >
  108. PILA< T > &PILA< T >::sacarPila (){
  109.      
  110.       PILA_DATOS< T > *temp;
  111.       temp = ptrPila;
  112.       ptrPila = ptrPila->ptrPilaSiguiente;
  113.       delete temp;
  114.       return *this;
  115.      
  116. }
  117.  
  118. template< class T >
  119. PILA< T > &PILA< T >::mostrarPila (){
  120.      
  121.       PILA_DATOS< T > *a = ptrPila;
  122.       while ( a != NULL ){
  123.             cout << a->nodo << "->";
  124.             a = a->ptrPilaSiguiente;
  125.       }
  126.       cout << "NULL" << endl;
  127.       return *this;
  128.      
  129. }
  130.  
  131. template< class U > ostream& operator<< ( ostream &salida,
  132. const PILA< U > &a ){
  133.      
  134.       salida << *( a.ptrPila );
  135.       return salida;
  136.      
  137. }
  138.  
  139. int main (){
  140.    
  141.     PILA< float > *a = new PILA< float >;
  142.     cout << *a;
  143.    
  144.     getchar();
  145.     return 0;
  146.    
  147. }
  148.  

Agradeceria cualquier recomendación de hacer algo mejor, sugerencias para hacer la clase más grande y ese tipo de cosas :P también le he añadido un destructor para reclamar el espacio asignado dinámicamente. Por cierto, es mucho más fácil hacerlo con estructuras no? yo había hecho estos ejercicios en C y me resultaron bastante más fácil xd

Un saludo y gracias por responder!!
Páginas: [1]
« anterior próximo »