Questo sito utilizza cookies, anche di terze parti, per mostrare pubblicità e servizi in linea con il tuo account. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Gestione coda generica
Forum - C/C++ - Gestione coda generica

Avatar
flavio89 (Normal User)
Rookie


Messaggi: 26
Iscritto: 07/09/2011

Segnala al moderatore
Postato alle 16:26
Martedì, 20/09/2011
Ho scritto un programma per la gestione di una coda e di una pila generica.
L'inizio dei due codici è uguale, ma la pila funziona e la coda no!
Nel codice riguardante la coda, inserisco il primo elemento, che ovviamente, in quanto primo, deve essere inserito in testa. Ma il programma, a quel punto va in crash!
Diversamente il codice sulla pila, che è il medesimo almeno all' inizio, funziona senza problemi.
Li posto entrambi:

Pila (funzionante)
Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef struct elem {
  5.     struct elem* next;
  6.     void* key;
  7. } elem;
  8.  
  9. elem* ins (elem*,void*,void*(*copia)(void*));
  10. void* copia (void*);
  11. elem* crea ();
  12. void stampa (elem*);
  13. elem* del_testa(elem*);
  14.  
  15. int num = 0;    // variabile globale
  16. main (){
  17.     void* n;
  18.     elem* head;
  19.     int r;
  20.  
  21.  
  22.     while (1) {
  23.         printf ("1. Push\n2. Pop\n3. Esci\n- ");
  24.         scanf ("%d",&r);
  25.  
  26.         if (r == 1) {
  27.            if (num < 10) {
  28.             printf ("numero da inserire in testa: ");
  29.             int insert;
  30.             fflush(stdin);
  31.             scanf ("%d",&insert);
  32.             n = &insert;                    // inserisce in *numero in variabile generica
  33.             *(int*) n = insert;             // casting con il tipo Intero
  34.  
  35.             head = ins (head,n,copia);
  36.             num++;
  37.  
  38.             stampa (head);
  39.             puts ("");
  40.             } // fine IF *num 10
  41.  
  42.            else puts ("Stack pieno");
  43.         } // fine IF
  44.  
  45.         else if (r == 2) {
  46.            if (num > 0) {
  47.             head = del_testa(head);         // eliminazione in testa
  48.             stampa (head);
  49.             puts ("");
  50.             num--;
  51.          } // fine IF *num 0
  52.           else puts ("Stack vuoto");
  53.         } // fine ELSE IF
  54.  
  55.         else if (r == 3) exit (1);
  56.         else puts ("Non valido\n");
  57.     } //fine WHILE INFINITO
  58. }
  59.  
  60. elem* ins (elem* head,void* k,void*(*copia)(void*)) {
  61.     elem* temp;
  62.     temp = malloc(sizeof(elem));
  63.     temp->next = head;
  64.     temp->key = copia (k);  // funzione per copiare intero
  65.     return temp;
  66.     }
  67.  
  68. void* copia (void* a) {
  69.     int* temp;
  70.     if ((temp = malloc(sizeof(int))) == NULL) return NULL;  // se ERRORE
  71.     *temp = *(int*) a;
  72.     return (void*) temp;
  73.     }
  74.  
  75.  
  76. void stampa (elem* head) {
  77.     elem* cur;
  78.     cur = head;
  79.     puts ("\nLISTA");
  80.  
  81.     while (cur->next != NULL) {
  82.     int t = *(int*)cur->key;        // deve mostrare un tipo INTERO
  83.     printf ("%d\n",t);
  84.     cur = cur->next;
  85.     }
  86. }
  87.  
  88. elem* del_testa (elem* head) {
  89.     head = head->next;
  90.     return head;
  91. }



Coda (crash al primo inserimento)
Codice sorgente - presumibilmente C++

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef struct elem {
  5.     struct elem* next;
  6.     void* key;
  7. } elem;
  8.  
  9.  
  10. elem* ins_testa (elem*,void*,void*(*copia)(void*));
  11. void* copia (void* a);
  12. elem* ins_coda (elem*,void* ,void*(*copia)(void*));
  13. elem* scorri (elem*);
  14. elem* del_testa (elem*);
  15. void stampa (elem*);
  16.  
  17.  
  18. main (){
  19.     void* n;
  20.     elem* head;
  21.     int r;
  22.     int num = 0;
  23.  
  24.     printf ("Inserire il primo elemento: ");
  25.             int insert;
  26.             fflush(stdin);
  27.             scanf ("%d",&insert);
  28.             n = &insert;                    // inserisce in numero in variabile generica
  29.             *(int*) n = insert;             // casting con il tipo Intero
  30.  
  31.             head = ins_testa (head,n,copia);
  32.             num++;
  33.  
  34.             //stampa (head);
  35.             puts ("");
  36.  
  37.     while (1) {
  38.  
  39.         printf ("1. Push\n2. Pop\n3. Esci\n- ");
  40.         scanf ("%d",&r);
  41.  
  42.         if (r == 1) {
  43.             if (num < 10) {
  44.             printf ("Numero da inserire in coda: ");
  45.             int insert;
  46.             fflush(stdin);
  47.             scanf ("%d",&insert);
  48.             n = &insert;                    // inserisce in numero in variabile generica
  49.             *(int*) n = insert;             // casting con il tipo Intero
  50.  
  51.             elem* corrente;
  52.             corrente = scorri (head);       // ultimo elemento lista
  53.             head = ins_coda (corrente,n,copia);
  54.             num++;
  55.  
  56.             puts ("");
  57.             } // fine IF
  58.  
  59.             else puts ("Stack pieno");
  60.             }   // fine CASE 1
  61.  
  62.         else if (r == 2) {
  63.             if (num > 0) {
  64.                 head = del_testa(head);
  65.  
  66.                 puts ("");
  67.                 num--;
  68.                 } // fine IF NUM > 0
  69.                 else puts ("Stack vuoto");
  70.                            } // fine ELSE IF CASE 2
  71.  
  72.         else if (r == 3) exit (1);
  73.         else if (r == 4) stampa (head);
  74.         else puts ("Non valido\n");
  75.         }   // FINE WHILE INFINITO
  76. }
  77.  
  78.  
  79. elem* ins_testa (elem* head,void* k,void*(*copia)(void*)) {
  80.     elem* temp;
  81.     temp = malloc(sizeof(elem));
  82.     temp->next = head;
  83.     temp->key = copia (k);  // funzione per copiare intero
  84.     return temp;
  85.     }
  86.  
  87. void* copia (void* a) {
  88.     int* temp;
  89.     if ((temp = malloc(sizeof(int))) == NULL) return NULL;  // se ERRORE
  90.     *temp = *(int*) a;
  91.     return (void*) temp;
  92.     }
  93.  
  94.  
  95. elem* ins_coda (elem* corrente,void* k,void*(*copia)(void*)) {
  96.     elem* temp;
  97.     temp = malloc(sizeof(elem));
  98.     temp->key = copia(k);
  99.     corrente->next = temp;
  100.     temp->next = NULL;
  101.     return temp;
  102.     }
  103.  
  104.  
  105. elem* scorri (elem* head) {
  106.     elem* cur;
  107.     cur = head;
  108.  
  109.     while (cur != NULL) {
  110.     cur = cur->next;
  111.     }
  112.  
  113.     head = cur;
  114.     return head;
  115. }
  116.  
  117. elem* del_testa (elem* head) {
  118.     head = head->next;
  119.     return head;
  120. }
  121.  
  122. void stampa (elem* head) {
  123.     elem* cur;
  124.     cur = head;
  125.     puts ("\nLISTA");
  126.  
  127.     while (cur->next != NULL) {
  128.     int t = *(int*)cur->key;        // deve mostrare un tipo INTERO
  129.     printf ("%d\n",t);
  130.     cur = cur->next;
  131.     }
  132. }



Tra le altre cose, per qualche motivo ho dovuto usare una serie di if piuttosto che lo switch.
Se qualcuno riuscisse a capire il perchè del crash, gli sarei grato.


C, con te litigo spesso, ma alla fin fine ti voglio bene
PM Quote
Avatar
nessuno (Normal User)
Guru^2


Messaggi: 5461
Iscritto: 03/01/2010

Segnala al moderatore
Postato alle 18:24
Martedì, 20/09/2011
Beh, tanto per cominciare scriverei

elem* head = NULL;

... per il resto c'è da controllare ...


Ricorda che nessuno è obbligato a risponderti e che nessuno è perfetto ...
PM Quote