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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


  Mostrar Mensajes
Páginas: [1]
1  Programación / Programación C/C++ / Re: Recursividad: Simulacion de ciclos (Imprimir una cadena alreves) en: 16 Septiembre 2013, 23:22 pm
Mejor manejalo con string y lee la cadena con getline(cin,variable) para que los espacios los cuentes y ya
2  Programación / Programación C/C++ / 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. }
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines