Diferenciar entrada de datos por consola

[eferion]

Iniciado por vangodp

jajaja ve! Era un 'if else' de templates jaja. Pfff Que complicadas son las plantillas cachis.

He visto pocas cosas con platillas(siempre intento evitarlas >_<), pero realmente el que las sabe sacar partido hacen maravillas con ellas. Otro día vi como se hacia un un nodo de una lista simples de una estructura con plantillas, no tenia ni idea de que se pudiera hacer esto. jajaja

A ver si un día llego a las plantillas, pero eso me parece ya muy hard para mi. >_<

La clave es pensar de forma diferente, conocer sus limitaciones (de los templates) y cómo sortear dichas limitaciones... y luego dejar todo bien documentado para no volverse loco.

vangodp, tu comentario me ha inspirado. Un ejemplo de una lista simple usando templates... la gracia está en que admite diferentes tipos de datos:

Código C++:

#include <iostream>
#include <string>
 
class NodoBase
{
  public:
 
    NodoBase( )
      : _siguiente( nullptr )
    { }
 
    virtual ~NodoBase( )
    { }
 
    void SetSiguiente( NodoBase* siguiente )
    { _siguiente = siguiente; }
 
    NodoBase* Siguiente( ) const
    { return _siguiente; }
 
    virtual void Pintar( std::ostream& out ) const = 0;
 
  private:
 
    NodoBase* _siguiente;
};
 
template< typename _TYPE_ >
class Nodo : public NodoBase
{
  public:
    Nodo( _TYPE_ valor )
      : _valor( valor )
    { }
 
    ~Nodo( )
    { }
 
    virtual void Pintar( std::ostream& out ) const
    { out << _valor; }
 
  private:
 
    _TYPE_ _valor;
};
 
class Lista
{
  public:
 
    Lista( )
      : _primero( nullptr )
    { }
 
    virtual ~Lista( )
    {
      while( _primero )
      {
        NodoBase* siguiente = _primero->Siguiente( );
        delete _primero;
        _primero = siguiente;
      }
    }
 
    template< class _TYPE_ >
    void NuevoItem( _TYPE_ valor )
    {
      NodoBase* nuevoNodo = new Nodo<_TYPE_>( valor );
 
      if ( !_primero )
        _primero = nuevoNodo;
      else
      {
        NodoBase* nodo = _primero;
        while( nodo->Siguiente( ) )
          nodo = nodo->Siguiente( );
 
        nodo->SetSiguiente( nuevoNodo );
      }
    }
 
    void Pintar( std::ostream& out )
    {
      if ( !_primero )
      {
        out << "Lista vacía" << std::endl;
        return;
      }
 
      _primero->Pintar( out );
      NodoBase* nodo = _primero->Siguiente( );
      while( nodo )
      {
        out << " -> ";
        nodo->Pintar( out );
        nodo = nodo->Siguiente( );
      }
 
      out << std::endl;
    }
 
  private:
 
    NodoBase* _primero;
};
 
int main( )
{
  Lista lista;
 
  lista.NuevoItem( 1 );
  lista.NuevoItem( 'c' );
  lista.NuevoItem( "prueba" );
  lista.NuevoItem( 4.56 );
 
  lista.Pintar( std::cout );
}
 

¿Por qué uso "NodoBase"?? por dos razones:

* Un template no puede tener un método virtual puro
* Las especializaciones de un template no tienen herencia común, class<int> no hereda, de ninguna forma, de class<T>, por lo que necesito un mecanismo que me permita incrustar tipos de "nodos" diferentes a partir de una clase común.

Un saludo.