• Sábado 14 de Diciembre de 2024, 23:54
« anterior próximo »
Páginas: [1]

Autor Tema:  Pila C  (Leído 3513 veces)

Jesus21

  • Nuevo Miembro
  • *
  • Mensajes: 7
    • Ver Perfil
Pila C
« en: Miércoles 16 de Marzo de 2011, 07:46 »
0
este es mi fuente pero no encuentro en donde esta el error ... segun yo esta bien :S
saludos y de antemano gracias.
sobre inicializar a nulo es donde tengo mas dudas ... lo puse como comentario pero no estoy seguro :S

Código: C
  1. #include <iostream.h>
  2.  
  3. typedef struct datos{
  4.         int dato;
  5.         struct datos *siguiente;
  6.         }tipoNodo;
  7.  
  8. typedef tipoNodo *pNodo;
  9. typedef tipoNodo *Pila;
  10.  
  11. void push (Pila *pila,int val);
  12. int pop (Pila *pila);
  13.  
  14. void push(Pila *pila,int val){
  15.      pNodo nuevo;
  16.      nuevo = (pNodo) malloc (sizeof(tipoNodo));
  17.      nuevo->dato = val;
  18.      nuevo->siguiente =*pila;
  19.      *pila = nuevo;
  20.      //*siguiente = NULL;
  21.      }
  22.      
  23. int pop(Pila *pila){
  24.      pNodo aux;
  25.      int v;
  26.      aux = *pila;
  27.      if (!aux) cout << "npila vacian";
  28.      *pila = aux->siguiente;
  29.      v = aux->dato;
  30.      free (aux);
  31.      cout << v;
  32.      system ("pause");
  33.      }
  34.  
  35.  main()
  36.  {
  37.       int x,op,val;
  38.       Pila *pila;
  39.       do{
  40.       system ("cls");
  41.       cout << "Pilas"
  42.       <<"n1- Insertar un nuevo elemento en la pilan2- Quitar el ultimo elemento de la pilan3- Mostrar el contenido de la pilan4- Salirnn";
  43.       fflush (stdin);
  44.       cin >> op;
  45.       switch (op){
  46.              case 1:
  47.                   cout <<"Que valor deseas asignarle a la variablen";
  48.                   cin >> val;
  49.                   push(*pila,val);
  50.                   break;
  51.              case 2:
  52.                 pop(*pila);
  53.                   break;
  54.              case 3:
  55.                   cout << pila ;
  56.                   break;
  57.              case 4:
  58.                   return 0;
  59.                   break;
  60.              
  61.      
  62.      default:cout << "Digita una opcion valida";}
  63.      system("npause");
  64.      }while (op!=4);
  65.        
  66.  
  67.        
  68. }
  69.  
« última modificación: Miércoles 16 de Marzo de 2011, 18:39 por Jesus21 »

m0skit0

  • Miembro de PLATA
  • *****
  • Mensajes: 2337
  • Nacionalidad: ma
    • Ver Perfil
    • http://fr33kk0mpu73r.blogspot.com/
Re: Pila C++
« Respuesta #1 en: Miércoles 16 de Marzo de 2011, 10:48 »
0
Weno realmente eso no es C++, es C con cin y cout...

Por favor, usa las etiquetas de código y especifica qué error y dónde te lo da.

Amilius

  • Miembro HIPER activo
  • ****
  • Mensajes: 665
    • Ver Perfil
Re: Pila C++
« Respuesta #2 en: Miércoles 16 de Marzo de 2011, 16:11 »
0
Si crees que ese código "está bien" entonces estas muy confundido en el tema de punteros. Primero tienes que desechar todo lo que crees saber de punteros y empezar desde 0.

Algunos errores:

1. No inicializaste los punteros a 0. Simplemente imperdonable.
2. Como el nombre de tipo que escogiste para "Pila" es malísimo definiste un doble puntero donde sólo era necesario un simple puntero, tal vez por accidente.
3. En lugar de pasar la dirección del puntero a push y pop, le pasas el valor apuntado. Seguro que no compila por que la función espera un doble puntero.

Deberías pasar los parámetros por referencia, una gran ventaja de C++ para mejorar la legibilidad de tu código. También puede ayudar mucho adoptar un estilo de programación para darles nombres apropiados a los tipos.


Código: C++
  1.  
  2. #include <iostream>
  3.  
  4. typedef int Valor;
  5.  
  6. struct Nodo
  7. {
  8.     Valor dato;
  9.     Nodo* abajo;
  10. };
  11.  
  12. typedef Nodo* PNodo;
  13.  
  14. bool push(PNodo& pPila, const Valor val)
  15. {
  16.     PNodo pNuevoNodo = new (std::nothrow) Nodo;
  17.     if (0 == pNuevoNodo) return false;
  18.     pNuevoNodo->abajo = pPila;
  19.     pNuevoNodo->dato = val;
  20.     pPila = pNuevoNodo;
  21.     return true;
  22. }
  23.  
  24. bool pop(PNodo& pPila, Valor& val)
  25. {
  26.     if (0 == pPila) return false;
  27.     PNodo pNodoDesechado = pPila;
  28.     pPila = pPila->abajo;
  29.     val = pNodoDesechado->dato;
  30.     delete pNodoDesechado;
  31.     return true;
  32. }
  33.  
  34. void mostrarPila(PNodo pPila)
  35. {
  36.     std::cout << "Pila:";
  37.     while (pPila)
  38.     {
  39.         std::cout << " " << pPila->dato;
  40.         pPila = pPila->abajo;
  41.     }
  42.     std::cout << std::endl;
  43. }
  44.  
  45. int main()
  46. {
  47.     PNodo pila = 0;
  48.     push(pila, 1);
  49.     mostrarPila(pila);
  50.     push(pila, 2);
  51.     mostrarPila(pila);
  52.     push(pila, 3);
  53.     mostrarPila(pila);
  54.     push(pila, 4);
  55.     mostrarPila(pila);
  56.     Valor v;
  57.     pop(pila, v);
  58.     mostrarPila(pila);
  59.     pop(pila, v);
  60.     mostrarPila(pila);
  61.     pop(pila, v);
  62.     mostrarPila(pila);
  63.     pop(pila, v);
  64.     mostrarPila(pila);
  65.     pop(pila, v);
  66.     mostrarPila(pila);
  67.  
  68.     // Pausa
  69.     char c[1];
  70.     std::cin.getline(c, 1);
  71. }
  72.  
  73.  

Esta es la versión usando clases, incluye constructor copia y operador de asignación. El operador new (std::nothrow) permite que la función push retorne falso si no existe suficiente memoria.

Código: C++
  1.  
  2. #include <iostream>
  3.  
  4. // Asi es en C++
  5.  
  6. typedef int Valor;
  7.  
  8. struct Nodo
  9. {
  10.     Valor dato;
  11.     Nodo* abajo;
  12. };
  13.  
  14. class Pila
  15. {
  16. public:
  17.     Pila() : pNodoSuperior(0) {}
  18.  
  19.     ~Pila()
  20.     {
  21.         limpiar();
  22.     }
  23.  
  24.     Pila(const Pila& p) : pNodoSuperior(0)
  25.     {
  26.         *this = p;
  27.     }
  28.  
  29.     const Pila& operator=(const Pila& p)
  30.     {
  31.         limpiar();
  32.         Nodo* pNodoActual = p.pNodoSuperior;
  33.         while (pNodoActual)
  34.         {
  35.             push(pNodoActual->dato);
  36.             pNodoActual = pNodoActual->abajo;
  37.         }
  38.         invertir();
  39.         return *this;
  40.     }
  41.  
  42.     void limpiar()
  43.     {
  44.         Nodo* pNodoTemp;
  45.         while (pNodoSuperior)
  46.         {
  47.             pNodoTemp = pNodoSuperior;
  48.             pNodoSuperior = pNodoSuperior->abajo;
  49.             delete pNodoTemp;
  50.         }
  51.     }
  52.  
  53.     bool push(const Valor& val)
  54.     {
  55.         Nodo* pNuevoNodo = new (std::nothrow) Nodo;
  56.         if (0 == pNuevoNodo) return false;
  57.         pNuevoNodo->abajo = pNodoSuperior;
  58.         pNuevoNodo->dato = val;
  59.         pNodoSuperior = pNuevoNodo;
  60.         return true;
  61.     }
  62.  
  63.     bool pop(Valor& val)
  64.     {
  65.         if (0 == pNodoSuperior) return false;
  66.         Nodo* pNodoDesechado = pNodoSuperior;
  67.         pNodoSuperior = pNodoSuperior->abajo;
  68.         val = pNodoDesechado->dato;
  69.         delete pNodoDesechado;
  70.         return true;
  71.     }
  72.  
  73.     void invertir()
  74.     {
  75.         Nodo* pNodoActual = pNodoSuperior;
  76.         Nodo* pNodoArriba = 0;
  77.         Nodo* pNodoAbajo;
  78.         while (pNodoActual)
  79.         {
  80.             pNodoAbajo = pNodoActual->abajo;
  81.             pNodoActual->abajo = pNodoArriba;
  82.             pNodoArriba = pNodoActual;
  83.             pNodoActual = pNodoAbajo;
  84.         }
  85.         pNodoSuperior = pNodoArriba;
  86.     }
  87.  
  88.     void mostrar() const
  89.     {
  90.         std::cout << "Pila: ";
  91.         Nodo* pNodoTemp = pNodoSuperior;
  92.         while (pNodoTemp)
  93.         {
  94.             std::cout << " " << pNodoTemp->dato;
  95.             pNodoTemp = pNodoTemp->abajo;
  96.         }
  97.         std::cout << std::endl;
  98.     }
  99.  
  100. private:
  101.     Nodo* pNodoSuperior;
  102.  
  103. };
  104.  
  105. int main()
  106. {
  107.     Pila p;
  108.     p.push(1);
  109.     p.mostrar();
  110.     p.push(2);
  111.     p.mostrar();
  112.     p.push(3);
  113.     p.mostrar();
  114.     p.push(4);
  115.     p.mostrar();
  116.     Valor v;
  117.    
  118.     Pila p1(p);
  119.  
  120.     p.pop(v);
  121.     p.mostrar();
  122.     p.pop(v);
  123.     p.mostrar();
  124.     p.pop(v);
  125.     p.mostrar();
  126.     p.pop(v);
  127.     p.mostrar();
  128.  
  129.     p1.mostrar();
  130.     p1.invertir();
  131.     p1.mostrar();
  132.  
  133.     // Pausa
  134.     char c[1];
  135.     std::cin.getline(c, 1);
  136. }
  137.  
  138.  
« última modificación: Jueves 17 de Marzo de 2011, 17:43 por Amilius »

Jesus21

  • Nuevo Miembro
  • *
  • Mensajes: 7
    • Ver Perfil
Re: Pila C++
« Respuesta #3 en: Miércoles 16 de Marzo de 2011, 18:34 »
0
ok perdon es C
y lo que debe de hacer el programa es pedir el valor al usuario y luego guardarlo en el nodo.

m0skit0

  • Miembro de PLATA
  • *****
  • Mensajes: 2337
  • Nacionalidad: ma
    • Ver Perfil
    • http://fr33kk0mpu73r.blogspot.com/
Re: Pila C
« Respuesta #4 en: Jueves 17 de Marzo de 2011, 09:39 »
0
Creo que Amilius ya te ha comentado tus errores, personalmente estoy de acuerdo con lo que dice, aunque su segundo ejemplo es bastante más adecuado a C++. Si vas a usar C, no uses cin/cout.

Saludos

Jesus21

  • Nuevo Miembro
  • *
  • Mensajes: 7
    • Ver Perfil
Re: Pila C
« Respuesta #5 en: Jueves 17 de Marzo de 2011, 18:59 »
0
si pero ese programa no registra los datos que digita el usuario que es lo que yo quiero hacer en la pila.
saludos

m0skit0

  • Miembro de PLATA
  • *****
  • Mensajes: 2337
  • Nacionalidad: ma
    • Ver Perfil
    • http://fr33kk0mpu73r.blogspot.com/
Re: Pila C
« Respuesta #6 en: Viernes 18 de Marzo de 2011, 08:20 »
0
Claro, es un ejemeplo. Tampoco te vamos a estar haciendo la tarea. Además añadirle eso que comentas es harto sencillo. Intenta hacerlo y nos cuentas.

Saludos

Jesus21

  • Nuevo Miembro
  • *
  • Mensajes: 7
    • Ver Perfil
Re: Pila C
« Respuesta #7 en: Viernes 18 de Marzo de 2011, 08:37 »
0
Cita de: "m0skit0"
Claro, es un ejemeplo. Tampoco te vamos a estar haciendo la tarea. Además añadirle eso que comentas es harto sencillo. Intenta hacerlo y nos cuentas.

Saludos


Ya lo termine el error estaba en inicializar a nulo ... Gracias por su ayuda.
Páginas: [1]
« anterior próximo »