elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Trabajando con las ramas de git (tercera parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Ayuda con Multi Listas POO C++
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Ayuda con Multi Listas POO C++  (Leído 5,403 veces)
hyperiod

Desconectado Desconectado

Mensajes: 2


Ver Perfil
Ayuda con Multi Listas POO C++
« en: 16 Septiembre 2013, 23:03 pm »

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
  1. #include <iostream>
  2. #include <stdlib.h>
  3. using namespace std;
  4.  
  5. ////////////////////////////////////////////////////////
  6.  
  7.  
  8.  
  9. class nodo {
  10.   public:
  11. //contructor clase nodo, que recibe un string y crea un apuntador a NULL
  12.    nodo(string v, nodo *sig = NULL)
  13.    {
  14.       valor = v;//parametro que se pasa es = valor que esta privado
  15.       siguiente = sig; //apuntador siguiente = apuntador sig
  16.    }
  17.  
  18.   private:
  19.    string valor;
  20.    nodo *siguiente;
  21.  
  22.   friend class Ingrediente;
  23.   friend class Postre;
  24. };
  25.  
  26. typedef nodo *pnodo;
  27.  
  28. //cambia el nombre de nodo a apuntador -->*pnodo
  29.  
  30.  
  31.  
  32. ////////////////////////////////////////////////////////
  33.  
  34.  
  35.  
  36.  
  37.  
  38. class Postre {
  39.   public:
  40.  
  41. //contructor que inicializa los valores privados de la clase
  42.    Postre() { primero = actual = NULL; }
  43. //Destructor
  44. ~Postre();
  45. //Metodos auxiliares de la clase lista
  46. //insertar que pasa un valor entero
  47.    void Insertar(string v);
  48.  
  49. //borrar que pasa un valor entero
  50.    void Borrar(string v);
  51. //boleano que regresa valor de primero que es igual a NULL
  52.    bool ListaVacia() { return primero == NULL; }
  53. //Muestra el arreglo
  54.    void Mostrar();
  55.    void Siguiente()
  56. {
  57. if(actual)
  58. {
  59. actual = actual->siguiente;
  60. }
  61. }
  62.  
  63.    void Primero()
  64. {
  65. actual = primero;
  66. }
  67.    void Ultimo()
  68. {
  69. Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente();
  70. }
  71.    bool Actual()
  72. {
  73. return actual != NULL;
  74. }
  75.    string ValorActual()
  76. {
  77. return actual->valor;
  78. }
  79.  
  80.   private:
  81.    pnodo primero;
  82.    pnodo actual;
  83.  
  84. };
  85.  
  86. Postre::~Postre() {
  87.   pnodo aux;
  88.  
  89.   while(primero) {
  90.      aux = primero;
  91.      primero = primero->siguiente;
  92.      delete aux;
  93.   }
  94.   actual = NULL;
  95. }
  96.  
  97. void Postre::Insertar(string v) {
  98.   pnodo anterior;
  99.  
  100.   // Si la lista está vacía
  101.   if(ListaVacia() || primero->valor > v) {
  102.      // Asignamos a lista un nuevo nodo de valor v y cuyo siguiente elemento es la lista actual                    
  103.      primero = new nodo(v, primero);
  104.   } else {
  105.      // Buscar el nodo de valor menor a v
  106.      anterior = primero;
  107.      // Avanzamos hasta el último elemento o hasta que el siguiente tenga un valor mayor que v
  108.      while(anterior->siguiente && anterior->siguiente->valor <= v)
  109.         anterior = anterior->siguiente;
  110.      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente es el siguiente del anterior
  111.      anterior->siguiente = new nodo(v, anterior->siguiente);
  112.   }
  113. }
  114.  
  115. void Postre::Borrar(string v) {
  116.   pnodo anterior, nodo;
  117.  
  118.   nodo = primero;
  119.   anterior = NULL;
  120.   while(nodo && nodo->valor < v) {
  121.      anterior = nodo;
  122.      nodo = nodo->siguiente;
  123.   }
  124.   if(!nodo || nodo->valor != v) return;
  125.   else { // Borrar el nodo
  126.      if(!anterior) // Primer elemento
  127.         primero = nodo->siguiente;
  128.      else  // un elemento cualquiera
  129.         anterior->siguiente = nodo->siguiente;
  130.      delete nodo;
  131.   }  
  132. }
  133.  
  134. void Postre::Mostrar() {
  135.   nodo *aux;
  136.  
  137.   aux = primero;
  138.   while(aux) {
  139.      cout << aux->valor << "-> ";
  140.      aux = aux->siguiente;
  141.   }
  142.   cout << endl;
  143. }
  144.  
  145.  
  146.  
  147. ////////////////////////////////////////////////////////
  148.  
  149.  
  150.  
  151.  
  152.  
  153.  
  154. class Ingrediente {
  155.   public:
  156. //contructor que inicializa los valores privados de la clase
  157.    Ingrediente() { primero = actual = NULL; }
  158. //Destructor
  159. ~Ingrediente();
  160. //Metodos auxiliares de la clase lista
  161. //insertar que pasa un valor entero
  162.    void Insertar(string v);
  163. //borrar que pasa un valor entero
  164.    void Borrar(string v);
  165. //boleano que regresa valor de primero que es igual a NULL
  166.    bool ListaVacia() { return primero == NULL; }
  167. //Muestra el arreglo
  168.    void Mostrar();
  169.    void Siguiente()
  170. {
  171. if(actual)
  172. {
  173. actual = actual->siguiente;
  174. }
  175. }
  176.  
  177.    void Primero()
  178. {
  179. actual = primero;
  180. }
  181.    void Ultimo()
  182. {
  183. Primero(); if(!ListaVacia()) while(actual->siguiente) Siguiente();
  184. }
  185.    bool Actual()
  186. {
  187. return actual != NULL;
  188. }
  189.    string ValorActual()
  190. {
  191. return actual->valor;
  192. }
  193.  
  194.   private:
  195.    pnodo primero;
  196.    pnodo actual;
  197. };
  198.  
  199. Ingrediente::~Ingrediente() {
  200.   pnodo aux;
  201.  
  202.   while(primero) {
  203.      aux = primero;
  204.      primero = primero->siguiente;
  205.      delete aux;
  206.   }
  207.   actual = NULL;
  208. }
  209.  
  210. void Ingrediente::Insertar(string v) {
  211.   pnodo anterior;
  212.  
  213.   // Si la lista está vacía
  214.   if(ListaVacia() || primero->valor > v) {
  215.      // Asignamos a lista un nuevo nodo de valor v y cuyo siguiente elemento es la lista actual                    
  216.      primero = new nodo(v, primero);
  217.   } else {
  218.      // Buscar el nodo de valor menor a v
  219.      anterior = primero;
  220.      // Avanzamos hasta el último elemento o hasta que el siguiente tenga un valor mayor que v
  221.      while(anterior->siguiente && anterior->siguiente->valor <= v)
  222.         anterior = anterior->siguiente;
  223.      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente es el siguiente del anterior
  224.      anterior->siguiente = new nodo(v, anterior->siguiente);
  225.   }
  226. }
  227.  
  228. void Ingrediente::Borrar(string v) {
  229.   pnodo anterior, nodo;
  230.  
  231.   nodo = primero;
  232.   anterior = NULL;
  233.   while(nodo && nodo->valor < v) {
  234.      anterior = nodo;
  235.      nodo = nodo->siguiente;
  236.   }
  237.   if(!nodo || nodo->valor != v) return;
  238.   else { // Borrar el nodo
  239.      if(!anterior) // Primer elemento
  240.         primero = nodo->siguiente;
  241.      else  // un elemento cualquiera
  242.         anterior->siguiente = nodo->siguiente;
  243.      delete nodo;
  244.   }  
  245. }
  246.  
  247. void Ingrediente::Mostrar() {
  248.   nodo *aux;
  249.  
  250.   aux = primero;
  251.   while(aux) {
  252.      cout << aux->valor << "-> ";
  253.      aux = aux->siguiente;
  254.   }
  255.   cout << endl;
  256. }
  257.  
  258.  
  259. ////////////////////////////////////////////////////////
  260.  
  261.  
  262.  
  263.  
  264. int main() {
  265.   Postre Lista;
  266.   Ingrediente Lista1;
  267.  
  268.  
  269.   Lista.Insertar("Pastel Chocolate");
  270.   Lista.Insertar("Pastel Fresa");
  271.  
  272.   Lista1.Insertar("Harina");
  273.   Lista1.Insertar("Crema");
  274.   Lista1.Insertar("Huevos");
  275.  
  276.   cout << "Lista de elementos:" << endl;
  277.   Lista.Primero();
  278.   while(Lista.Actual()) {
  279.      cout << Lista.ValorActual() << endl;
  280.      Lista.Siguiente();
  281.   }
  282.   Lista.Primero();
  283.   cout << "Primero: " << Lista.ValorActual() << endl;
  284.  
  285.   Lista.Ultimo();
  286.   cout << "Ultimo: " << Lista.ValorActual() << endl;
  287.  
  288.  
  289.   cout << "Lista de elementos:" << endl;
  290.   Lista1.Primero();
  291.   while(Lista1.Actual()) {
  292.      cout << Lista1.ValorActual() << endl;
  293.      Lista1.Siguiente();
  294.   }
  295.   Lista1.Primero();
  296.   cout << "Primero: " << Lista1.ValorActual() << endl;
  297.  
  298.   Lista1.Ultimo();
  299.   cout << "Ultimo: " << Lista1.ValorActual() << endl;
  300.  
  301.  
  302. system("PAUSE");
  303.   return 0;
  304. }


« Última modificación: 16 Septiembre 2013, 23:10 pm por hyperiod » En línea

eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Ayuda con Multi Listas POO C++
« Respuesta #1 en: 17 Septiembre 2013, 09:17 am »

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
  1. class Ingrediente
  2. {
  3.  public:
  4.    Ingrediente( const std::string nombre )
  5.      : _nombre( nombre ),
  6.        _siguiente_ingrediente( nullptr )
  7.    {
  8.    }
  9.  
  10.    const std::string& Nombre( ) const
  11.    {
  12.      return _nombre;
  13.    }
  14.  
  15.    Ingrediente* SiguienteIngrediente( ) const
  16.    {
  17.      return _siguiente_ingrediente;
  18.    }
  19.  
  20.    void SetSiguienteIngrediente( Ingrediente* ingrediente )
  21.    {
  22.      _siguiente_ingrediente = ingrediente;
  23.    }
  24.  
  25.  private:
  26.    std::string _nombre;
  27.    Ingrediente* _siguiente_ingrediente;
  28. };
  29.  
  30. class Postre
  31. {
  32.  public:
  33.    Postre( const std::string& nombre )
  34.      : _nombre( nombre ),
  35.        _siguiente_postre( nullptr ),
  36.        _primer_ingrediente( nullptr )
  37.    { }
  38.  
  39.    ~Postre( )
  40.    {
  41.      Ingrediente* ingrediente = _primer_ingrediente;
  42.      while ( ingrediente )
  43.      {
  44.        Ingrediente* para_borrar = ingrediente;
  45.        ingrediente = ingrediente->SiguienteIngrediente( );
  46.        delete para_borrar;
  47.      }
  48.    }
  49.  
  50.    const std::string& Nombre( ) const
  51.    {
  52.      return _nombre;
  53.    }
  54.  
  55.    void SetSiguientePostre( Postre* siguiente_postre )
  56.    {
  57.      _siguiente_postre = siguiente_postre;
  58.    }
  59.  
  60.    Postre* SiguientePostre( ) const
  61.    {
  62.      return _siguiente_postre;
  63.    }
  64.  
  65.    Ingrediente* PrimerIngrediente( ) const
  66.    {
  67.      return _primer_ingrediente;
  68.    }
  69.  
  70.    void NuevoIngrediente( const std::string& nombre )
  71.    {
  72.      Ingrediente* ingrediente_actual = _primer_ingrediente;
  73.      while ( ingrediente_actual->SiguienteIngrediente( ) )
  74.        ingrediente_actual = ingrediente_actual->SiguienteIngrediente( );
  75.  
  76.      ingrediente_actual->SetSiguienteIngrediente( new Ingrediente( nombre ) );
  77.    }
  78.  
  79.    void EliminarIngrediente( const std::string& nombre )
  80.    {
  81.      Ingrediente* ingrediente_anterior = nullptr;
  82.      Ingrediente* ingrediente_actual = _primer_ingrediente;
  83.      while ( ingrediente_actual )
  84.      {
  85.        if ( ingrediente_actual->Nombre( ) == nombre )
  86.        {
  87.          if ( ingrediente_anterior )
  88.            ingrediente_anterior->SetSiguiente( ingrediente_actual->Siguiente( ) );
  89.          else
  90.            _primer_ingrediente = ingrediente_actual->Siguiente( );
  91.          delete ingrediente_actual;
  92.          break;
  93.        }            
  94.        ingrediente_anterior = ingrediente_actual;
  95.        ingrediente_actual = ingrediente_actual->SiguienteIngrediente( );
  96.    }
  97.  
  98.  private:
  99.    std::string _nombre;
  100.    Postre* _siguiente_postre;
  101.    Ingrediente* _primer_ingrediente;
  102. };

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

Código
  1. class ListaIngredientes
  2. {
  3.  public:
  4.    ListaIngredientes( )
  5.      : _primer_postre( nullptr )
  6.    {
  7.    }
  8.  
  9.    ~ListaIngredientes( )
  10.    {
  11.      Postre* postre = _primer_postre;
  12.      while ( postre)
  13.      {
  14.        Postre* para_borrar = postre;
  15.        postre= postre->SiguientePostre( );
  16.        delete para_borrar;
  17.      }
  18.    }
  19.  
  20.    Postre* NuevoPostre( const std::string& nombre )
  21.    {
  22.      Postre* postre = _primer_postre;
  23.      while ( postre->SiguientePostre( ) )
  24.        postre = postre->SiguientePostre( );
  25.  
  26.      postre->SetSiguientePostre( new Postre( nombre ) );
  27.      return postre->SiguientePostre( );
  28.    }
  29.  
  30.    Postre* BuscarPostre( const std::string& nombre ) const
  31.    {
  32.      Postre* postre = _primer_postre;
  33.      while ( postre )
  34.      {
  35.        if ( postre->Nombre( ) == nombre )
  36.          return postre;
  37.      }
  38.  
  39.      return nullptr; // no hay postres con el nombre indicado
  40.    }
  41.  
  42.    void BorrarPostre( const std::string& nombre )
  43.    {
  44.      Postre* postre_anterior = nullptr;
  45.      Postre* postre = _primer_postre;
  46.      while ( postre )
  47.      {
  48.        if ( postre->Nombre( ) == nombre )
  49.        {
  50.          if ( postre_anterior )
  51.            postre_anterior->SetSiguientePostre( postre->SiguientePostre( ) );
  52.          else
  53.            _primer_postre = postre->SiguientePostre( );
  54.  
  55.          delete postre;
  56.      }
  57.    }
  58.  
  59.  private:
  60.    Postre* _primer_postre;
  61. };

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.


En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
ayuda con 2 LISTAS
Programación Visual Basic
forrestgump 0 886 Último mensaje 4 Junio 2008, 22:25 pm
por forrestgump
Uso de Listas: Subprograma que lea 2 listas y forme una.
Dudas Generales
hbenitez 2 2,367 Último mensaje 8 Agosto 2010, 20:11 pm
por hbenitez
Ayuda Acerca De Listas y Listas Circulares (Revienta Memoria :S)
Programación C/C++
Gerik 0 2,100 Último mensaje 12 Septiembre 2010, 01:49 am
por Gerik
Ayuda con codigo de Listas [C++]
Programación C/C++
Lakon 0 4,329 Último mensaje 1 Noviembre 2010, 18:32 pm
por Lakon
Listas Dinamicas[AYUDA]
Programación C/C++
andressitto007 6 2,819 Último mensaje 11 Abril 2011, 08:24 am
por Akai
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines