Programación General > C/C++
Sobrecarga de << con template
(1/1)
Checho360:
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++ ---#include <iostream>#include <new>using namespace std; template< class T >class PILA_DATOS{ template< class t > friend class PILA; private: T nodo; PILA_DATOS< T > *ptrPilaSiguiente; }; template< class T >class PILA{ friend ostream &operator<< <T>( ostream &, const PILA< T > & ); public: PILA(); PILA< T > &empujarPila ( const T& ); PILA< T > &sacarPila (); private: PILA_DATOS< T > *ptrPila; bool estaVacia (); }; template< class T >PILA< T >::PILA (){ ptrPila = NULL; } template< class T >bool PILA< T >::estaVacia (){ return ( ptrPila == NULL ? true : false ); } template< class T >PILA< T > &PILA< T >::empujarPila ( const T &a ){ if ( estaVacia () ){ ptrPila = new PILA_DATOS< T >; ptrPila->nodo = a; ptrPila->ptrPilaSiguiente = NULL; } else{ PILA_DATOS< T > *nuevaPila; nuevaPila= new PILA_DATOS< T >; nuevaPila->nodo = a; nuevaPila->ptrPilaSiguiente = ptrPila; ptrPila = nuevaPila; } return *this; } template< class T >PILA< T > &PILA< T >::sacarPila (){ PILA_DATOS< T > *temp; temp = ptrPila; ptrPila = ptrPila->ptrPilaSiguiente; delete temp; return *this; } template< class T >ostream &operator<<( ostream &salida, const PILA< T > &pila ){ PILA_DATOS< T > *a = pila.ptrPila; while ( a != NULL ){ salida << a->nodo << "->"; a = a->ptrPilaSiguiente; } salida << "NULL\n"; return salida; } int main (){ PILA< int > a; a.empujarPila (2).empujarPila (3).empujarPila(23).empujarPila (25); cout << a; a.sacarPila().sacarPila(); cout << a; getchar(); return 0; }
Muchas gracias!
Geo:
¿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 ;).
Checho360:
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++ ---#include <iostream>#include <new>using namespace std; template< class T >class PILA_DATOS{ template< class t > friend class PILA; public: template< class U > friend ostream& operator<< ( ostream &, const PILA_DATOS< U > & ); PILA_DATOS< T > &operator= ( PILA_DATOS< T > & ); private: T nodo; PILA_DATOS< T > *ptrPilaSiguiente; }; template< class U > ostream& operator<< ( ostream &salida,const PILA_DATOS< U > &a ){ salida << a.nodo << "->"; PILA_DATOS< U > *b = a.ptrPilaSiguiente; while ( b != NULL ){ salida << b->nodo << "->"; b = b->ptrPilaSiguiente; } salida << "NULL" << endl; return salida; }template< class T >PILA_DATOS< T >& PILA_DATOS< T >::operator= ( PILA_DATOS< T > &a ){ nodo = a.nodo; ptrPilaSiguiente = a.ptrPilaSiguiente; return *this; } template< class T >class PILA{ public: PILA (); ~PILA (); PILA< T > &empujarPila ( const T& ); PILA< T > &sacarPila (); PILA< T > &mostrarPila (); template< class U > friend ostream& operator<< ( ostream &, const PILA< U > & ); private: PILA_DATOS< T > *ptrPila; bool estaVacia (); }; template< class T >PILA< T >::PILA (){ ptrPila = NULL; } template< class T >PILA< T >::~PILA (){ while ( ptrPila != NULL ){ PILA_DATOS< T > *temp = ptrPila; ptrPila = ptrPila->ptrPilaSiguiente; delete temp; } } template< class T >bool PILA< T >::estaVacia (){ return ( ptrPila == NULL ? true : false ); } template< class T >PILA< T > &PILA< T >::empujarPila ( const T &a ){ if ( estaVacia () ){ ptrPila = new PILA_DATOS< T >; ptrPila->nodo = a; ptrPila->ptrPilaSiguiente = NULL; } else{ PILA_DATOS< T > *nuevaPila; nuevaPila= new PILA_DATOS< T >; nuevaPila->nodo = a; nuevaPila->ptrPilaSiguiente = ptrPila; ptrPila = nuevaPila; } return *this; } template< class T >PILA< T > &PILA< T >::sacarPila (){ PILA_DATOS< T > *temp; temp = ptrPila; ptrPila = ptrPila->ptrPilaSiguiente; delete temp; return *this; } template< class T >PILA< T > &PILA< T >::mostrarPila (){ PILA_DATOS< T > *a = ptrPila; while ( a != NULL ){ cout << a->nodo << "->"; a = a->ptrPilaSiguiente; } cout << "NULL" << endl; return *this; } template< class U > ostream& operator<< ( ostream &salida,const PILA< U > &a ){ salida << *( a.ptrPila ); return salida; } int main (){ PILA< float > *a = new PILA< float >; cout << *a; getchar(); return 0; }
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!!
Navegación
Ir a la versión completa