Mensajes

Mejor manejalo con string y lee la cadena con getline(cin,variable) para que los espacios los cuentes y ya

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;
}