Ayuda con Multi Listas POO C++

[hyperiod]

Necesito ayuda con lo siguiente:

Se ha definido la siguiente estructura de datos:




Escribir un programa que realice lo siguiente:
a) Dado el nombre de un postre, imprimir la lista de todos sus ingredientes.
b) Dado el nombre de un postre, insertar nuevos ingredientes a su correspondiente lista.
c) Dado el nombre de un postre, eliminar alguno de sus ingredientes.
d) Dar de alta un postre con todos sus ingredientes.
e) Dar de baja un postre con todos sus ingredientes.


Ya tengo mi clase nodo, clase listaPostre y listaIngrediente. La duda que tengo es cómo apuntar el nombre del postre hacia otra lista para que despliegue los ingredientes. Adjunto mi código

Código (csharp) [Seleccionar] Expandir


#include <iostream>
#include <stdlib.h>
using namespace std;

////////////////////////////////////////////////////////



class nodo {
  public:
//contructor clase nodo, que recibe un string y crea un apuntador a NULL
   nodo(string v, nodo *sig = NULL)
   {
      valor = v;//parametro que se pasa es = valor que esta privado
      siguiente = sig; //apuntador siguiente = apuntador sig
   }

  private:
   string valor;
   nodo *siguiente;
       
  friend class Ingrediente;
  friend class Postre;
};

typedef nodo *pnodo;

//cambia el nombre de nodo a apuntador -->*pnodo



////////////////////////////////////////////////////////





class Postre {
  public:
 
//contructor que inicializa los valores privados de la clase
   Postre() { primero = actual = NULL; }
//Destructor
~Postre();
//Metodos auxiliares de la clase lista
//insertar que pasa un valor entero
   void Insertar(string v);
   
//borrar que pasa un valor entero
   void Borrar(string v);
//boleano que regresa valor de primero que es igual a NULL
   bool ListaVacia() { return primero == NULL; }
//Muestra el arreglo
   void Mostrar();
   void Siguiente()
{
if(actual)
{
actual = actual->siguiente;
}
}

   void Primero()
{
actual = primero;
}
   void Ultimo()
{
Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente();
}
   bool Actual()
{
return actual != NULL;
}
   string ValorActual()
{
return actual->valor;
}
   
  private:
   pnodo primero;
   pnodo actual;
   
};

Postre::~Postre() {
  pnodo aux;
 
  while(primero) {
     aux = primero;
     primero = primero->siguiente;
     delete aux;
  }
  actual = NULL;
}

void Postre::Insertar(string v) {
  pnodo anterior;

  // Si la lista está vacía
  if(ListaVacia() || primero->valor > v) {
     // Asignamos a lista un nuevo nodo de valor v y cuyo siguiente elemento es la lista actual                    
     primero = new nodo(v, primero);
  } else {
     // Buscar el nodo de valor menor a v
     anterior = primero;
     // Avanzamos hasta el último elemento o hasta que el siguiente tenga un valor mayor que v
     while(anterior->siguiente && anterior->siguiente->valor <= v)
        anterior = anterior->siguiente;
     // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente es el siguiente del anterior
     anterior->siguiente = new nodo(v, anterior->siguiente);
  }
}

void Postre::Borrar(string v) {
  pnodo anterior, nodo;
 
  nodo = primero;
  anterior = NULL;
  while(nodo && nodo->valor < v) {
     anterior = nodo;
     nodo = nodo->siguiente;
  }
  if(!nodo || nodo->valor != v) return;
  else { // Borrar el nodo
     if(!anterior) // Primer elemento
        primero = nodo->siguiente;
     else  // un elemento cualquiera
        anterior->siguiente = nodo->siguiente;
     delete nodo;
  }  
}

void Postre::Mostrar() {
  nodo *aux;
 
  aux = primero;
  while(aux) {
     cout << aux->valor << "-> ";
     aux = aux->siguiente;
  }
  cout << endl;
}



////////////////////////////////////////////////////////






class Ingrediente {
  public:
//contructor que inicializa los valores privados de la clase
   Ingrediente() { primero = actual = NULL; }
//Destructor
~Ingrediente();
//Metodos auxiliares de la clase lista
//insertar que pasa un valor entero
   void Insertar(string v);
//borrar que pasa un valor entero
   void Borrar(string v);
//boleano que regresa valor de primero que es igual a NULL
   bool ListaVacia() { return primero == NULL; }
//Muestra el arreglo
   void Mostrar();
   void Siguiente()
{
if(actual)
{
actual = actual->siguiente;
}
}

   void Primero()
{
actual = primero;
}
   void Ultimo()
{
Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente();
}
   bool Actual()
{
return actual != NULL;
}
   string ValorActual()
{
return actual->valor;
}
   
  private:
   pnodo primero;
   pnodo actual;
};

Ingrediente::~Ingrediente() {
  pnodo aux;
 
  while(primero) {
     aux = primero;
     primero = primero->siguiente;
     delete aux;
  }
  actual = NULL;
}

void Ingrediente::Insertar(string v) {
  pnodo anterior;

  // Si la lista está vacía
  if(ListaVacia() || primero->valor > v) {
     // Asignamos a lista un nuevo nodo de valor v y cuyo siguiente elemento es la lista actual                    
     primero = new nodo(v, primero);
  } else {
     // Buscar el nodo de valor menor a v
     anterior = primero;
     // Avanzamos hasta el último elemento o hasta que el siguiente tenga un valor mayor que v
     while(anterior->siguiente && anterior->siguiente->valor <= v)
        anterior = anterior->siguiente;
     // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente es el siguiente del anterior
     anterior->siguiente = new nodo(v, anterior->siguiente);
  }
}

void Ingrediente::Borrar(string v) {
  pnodo anterior, nodo;
 
  nodo = primero;
  anterior = NULL;
  while(nodo && nodo->valor < v) {
     anterior = nodo;
     nodo = nodo->siguiente;
  }
  if(!nodo || nodo->valor != v) return;
  else { // Borrar el nodo
     if(!anterior) // Primer elemento
        primero = nodo->siguiente;
     else  // un elemento cualquiera
        anterior->siguiente = nodo->siguiente;
     delete nodo;
  }  
}

void Ingrediente::Mostrar() {
  nodo *aux;
 
  aux = primero;
  while(aux) {
     cout << aux->valor << "-> ";
     aux = aux->siguiente;
  }
  cout << endl;
}


////////////////////////////////////////////////////////




int main() {
  Postre Lista;
  Ingrediente Lista1;
 
 
  Lista.Insertar("Pastel Chocolate");
  Lista.Insertar("Pastel Fresa");
   
  Lista1.Insertar("Harina");
  Lista1.Insertar("Crema");
  Lista1.Insertar("Huevos");
 
  cout << "Lista de elementos:" << endl;
  Lista.Primero();
  while(Lista.Actual()) {
     cout << Lista.ValorActual() << endl;
     Lista.Siguiente();
  }
  Lista.Primero();
  cout << "Primero: " << Lista.ValorActual() << endl;
 
  Lista.Ultimo();
  cout << "Ultimo: " << Lista.ValorActual() << endl;
 
 
  cout << "Lista de elementos:" << endl;
  Lista1.Primero();
  while(Lista1.Actual()) {
     cout << Lista1.ValorActual() << endl;
     Lista1.Siguiente();
  }
  Lista1.Primero();
  cout << "Primero: " << Lista1.ValorActual() << endl;
 
  Lista1.Ultimo();
  cout << "Ultimo: " << Lista1.ValorActual() << endl;
 

system("PAUSE");
  return 0;
}

[eferion]

Según la imagen, necesitas dos tipos de "nodos" diferentes... uno para el postre y otro para los ingredientes.

La diferencia básica es que el nodo de postres tiene que tener 2 punteros... uno para pasar al siguiente postre y otro para listar los ingredientes.

Con esto, yo eliminaría la clase nodo ya que no te va a aportar nada. Únicamente necesitas dos clases: Postre e Ingrediente.

Código (cpp) [Seleccionar] Expandir


class Ingrediente
{
  public:
    Ingrediente( const std::string nombre )
      : _nombre( nombre ),
        _siguiente_ingrediente( nullptr )
    {
    }

    const std::string& Nombre( ) const
    {
      return _nombre;
    }

    Ingrediente* SiguienteIngrediente( ) const
    {
      return _siguiente_ingrediente;
    }

    void SetSiguienteIngrediente( Ingrediente* ingrediente )
    {
      _siguiente_ingrediente = ingrediente;
    }

  private:
    std::string _nombre;
    Ingrediente* _siguiente_ingrediente;
};

class Postre
{
  public:
    Postre( const std::string& nombre )
      : _nombre( nombre ),
        _siguiente_postre( nullptr ),
        _primer_ingrediente( nullptr )
    { }

    ~Postre( )
    {
      Ingrediente* ingrediente = _primer_ingrediente;
      while ( ingrediente )
      {
        Ingrediente* para_borrar = ingrediente;
        ingrediente = ingrediente->SiguienteIngrediente( );
        delete para_borrar;
      }
    }

    const std::string& Nombre( ) const
    {
      return _nombre;
    }

    void SetSiguientePostre( Postre* siguiente_postre )
    {
      _siguiente_postre = siguiente_postre;
    }

    Postre* SiguientePostre( ) const
    {
      return _siguiente_postre;
    }

    Ingrediente* PrimerIngrediente( ) const
    {
      return _primer_ingrediente;
    }

    void NuevoIngrediente( const std::string& nombre )
    {
      Ingrediente* ingrediente_actual = _primer_ingrediente;
      while ( ingrediente_actual->SiguienteIngrediente( ) )
        ingrediente_actual = ingrediente_actual->SiguienteIngrediente( );

      ingrediente_actual->SetSiguienteIngrediente( new Ingrediente( nombre ) );
    }

    void EliminarIngrediente( const std::string& nombre )
    {
      Ingrediente* ingrediente_anterior = nullptr;
      Ingrediente* ingrediente_actual = _primer_ingrediente;
      while ( ingrediente_actual )
      {
        if ( ingrediente_actual->Nombre( ) == nombre )
        {
          if ( ingrediente_anterior )
            ingrediente_anterior->SetSiguiente( ingrediente_actual->Siguiente( ) );
          else
            _primer_ingrediente = ingrediente_actual->Siguiente( );
          delete ingrediente_actual;
          break;
        }           
        ingrediente_anterior = ingrediente_actual;
        ingrediente_actual = ingrediente_actual->SiguienteIngrediente( );
    }
 
  private:
    std::string _nombre;
    Postre* _siguiente_postre;
    Ingrediente* _primer_ingrediente;
};

Y luego, para rematar, puedes tener una tercera clase, una suerte de gestor de ingredientes para evitar código en el main:

Código (cpp) [Seleccionar] Expandir


class ListaIngredientes
{
  public:
    ListaIngredientes( )
      : _primer_postre( nullptr )
    {
    }

    ~ListaIngredientes( )
    {
      Postre* postre = _primer_postre;
      while ( postre)
      {
        Postre* para_borrar = postre;
        postre= postre->SiguientePostre( );
        delete para_borrar;
      }
    }

    Postre* NuevoPostre( const std::string& nombre )
    {
      Postre* postre = _primer_postre;
      while ( postre->SiguientePostre( ) )
        postre = postre->SiguientePostre( );

      postre->SetSiguientePostre( new Postre( nombre ) );
      return postre->SiguientePostre( );
    }

    Postre* BuscarPostre( const std::string& nombre ) const
    {
      Postre* postre = _primer_postre;
      while ( postre )
      {
        if ( postre->Nombre( ) == nombre )
          return postre;
      }

      return nullptr; // no hay postres con el nombre indicado
    }

    void BorrarPostre( const std::string& nombre )
    {
      Postre* postre_anterior = nullptr;
      Postre* postre = _primer_postre;
      while ( postre )
      {
        if ( postre->Nombre( ) == nombre )
        {
          if ( postre_anterior )
            postre_anterior->SetSiguientePostre( postre->SiguientePostre( ) );
          else
            _primer_postre = postre->SiguientePostre( );

          delete postre;
      }
    }

  private:
    Postre* _primer_postre;
};

Con esto creo que hacer el main para que cumpla con los requisitos es moco de pavo, no?? Incluso si te parece más limpio, puedes añadir los métodos para imprimir los ingredientes en la clase Postre... eso ya es a gusto de cada uno.

Y con respecto al uso de friend... úsalo con cuidado. La razón de encapsular el código es para que las clases sólo se puedan usar de una forma determinada... saltarse esa encapsulación no suele ser una buena idea. friend puede estar bien si diseñas algún tipo de API, para evitar, por ejemplo, que se puedan crear un objeto desde clases que no pertenezcan a dicha API... pero para prácticas de clase, salvo que estén específicamente pensadas para usar friend... no hacen falta.