Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
C/C++ - Correzione esercizio su Liste
Forum - C/C++ - Correzione esercizio su Liste

Pagine: [ 1 2 3 ] Precedente | Prossimo
Avatar
Djot (Normal User)
Rookie


Messaggi: 28
Iscritto: 14/02/2017

Segnala al moderatore
Postato alle 18:42
Martedì, 14/02/2017
Questo topic è stato chiuso dal moderatore

Salve a tutti , premetto di essere un novizio della programmazione in generale , volevo chiedervi un aiuto riguardo un esercizio da me svolto ;
L'esercizio consisteva nel generare strutture dati necessarie a rappresentare una lista di escursioni(composta da luogo di partenza ,
luogo di arrivo , distanza percorsa e tempo impiegato) e definire una funzione che dato un intero i restituisce luogo di partenza e di arrivo dellÂ’escursione in posizione i-esima.
Il mio codice è questo :

Codice sorgente - presumibilmente C++
  1. #include <iostream>
  2. #include <malloc.h>
  3. using namespace std;
  4. int const x = 200;
  5.  
  6. struct Escursione{
  7.         char luogoPartenza[x];
  8.         char luogoArrivo[x];
  9.         int distanza;
  10.         int tempo;
  11. };
  12. Escursione e1 , e2 , e3;
  13. struct lista{
  14.         Escursione val;
  15.         lista *next;
  16. };
  17. void creaLista(lista , Escursione){
  18.         Escursione e1 , e2 , e3;
  19.         typedef lista* ptr_lista;
  20.         ptr_lista primo;
  21.         primo->val=e1;
  22.         ptr_lista secondo;
  23.         primo->next=secondo;
  24.         secondo->val=e2;
  25.         ptr_lista terzo;
  26.         secondo->next=terzo;
  27.         terzo->val=e3;
  28.         ptr_lista coda;
  29.         terzo->next=coda;
  30.         coda->val=NULL;
  31. }
  32. void leggi(lista , Escursione){
  33.         lista *q;
  34.         q=primo;
  35.         while(q!=NULL){
  36.                 cout << q->val;
  37.                 q=q->next;
  38.         }
  39. }
  40. int main(lista,Escursione){
  41.         int n , i;
  42.         for(cin >> i; i<=n ; i++){
  43.                 if(i==e1.distanza)
  44.                         cout << e1.luogoArrivo << e1.luogoPartenza;
  45.                 else if(i==e2.distanza)
  46.                         cout << e2.luogoArrivo << e2.luogoPartenza;
  47.                 else if(i==e3.distanza)
  48.                         cout << e2.luogoArrivo << e3.luogoPartenza;
  49.                 else
  50.                         cout << "Errore";
  51.        }
  52.         return 0;
  53. }


Se potete elencare eventuali e probabili errori ve ne sarei grato.
Grazie mille a tutti

Ultima modifica effettuata da Djot il 14/02/2017 alle 19:50
PM
Avatar
lumo (Member)
Expert


Messaggi: 449
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 0:58
Mercoledì, 15/02/2017
Da dove stai imparando il C++? Ci sono moltissimi errori di base, sarebbe troppo lungo spiegarli tutti, magari possiamo aiutarti a trovare risorse migliori.

PM
Avatar
torn24 (Normal User)
Pro


Messaggi: 156
Iscritto: 04/01/2008

Segnala al moderatore
Postato alle 8:31
Mercoledì, 15/02/2017
Hai usato due struct "strutture dati record" e va bene, ma sbagli e non hai creato nessuna lista.
Una lista è una struttura dati dinamica, quindi prevede puntatori e allocazione dinamica della memoria.
I passi sono

1) Si crea un nodo puntatore Lista, e si alloca memoria
2) Si inseriscono i dati nei vari campi del nodo
3) Si crea una funzione inserisci nodo, che crea un nuovo nodo, inserisce valori nei campi, e concatena il nuovo nodo alla Lista.

Sbagli il passaggio di parametri alle funzioni "da qui mi domando se non è troppo presto che tu ti cimenti con le liste, forse dovresti fare un ripasso di concetti base", comunque per passare un argomento a una funzione,
occorre specificane nella funzione TIPO e parametro  Esempio  void creaLista(lista l , Escursione e), vedi aggiunta di "l" e "e".


In pratica usi Escursione e1 , e2 , e3; che sono semplici struct, ma non crei nessuna lista.
Parere personale.
Per affrontare l'esercizio dovresti ripassare puntatori a struct e studiare esempi di lista.

PM
Avatar
AldoBaldo (Member)
Guru


Messaggi: 699
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 22:10
Mercoledì, 15/02/2017
Viste le premesse, non sarebbe consigliabile tentare un'implementazione per mezzo di un array statico di dimensioni fisse per predisporre alcuni elementi base del programma e dopo modificare le cose per basarle effettivamente sull'impiego di una lista concatenata con allocazione dinamica dei nuovi record? Spero d'essere riuscito a spiegarmi.

ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM
Avatar
AldoBaldo (Member)
Guru


Messaggi: 699
Iscritto: 08/01/2015

Segnala al moderatore
Postato alle 0:33
Giovedì, 16/02/2017
Tipo...

File escursione.h:

Codice sorgente - presumibilmente C
  1. #ifndef ESCURSIONE_H
  2. #define ESCURSIONE_H
  3.  
  4. #define QMAXESC  64 // la quantita' massima di escursioni
  5. #define LMAXSTR 255 // la lunghezza massima delle stringhe
  6.  
  7. typedef struct ESCURSIONE {
  8.     char lp[LMAXSTR+1]; // luogo di partenza
  9.     char la[LMAXSTR+1]; // luogo di arrivo
  10.     unsigned int d;     // la distanza (in metri)
  11.     unsigned int t;     // il tempo richiesto (in minuti)
  12. } ESCURSIONE;
  13.  
  14. ESCURSIONE *CreaEscursione( void );
  15. void DistruggiEscursione( ESCURSIONE **e );
  16.  
  17. int AggiungiEscursione( ESCURSIONE **esc, unsigned int *qEsc );
  18. void EliminaEscursione( ESCURSIONE **esc, unsigned int *qEsc );
  19.  
  20. void ImpostaEscursione( ESCURSIONE *e,
  21.     const char *partenza, const char *arrivo,
  22.     double km, unsigned int h, unsigned int m );
  23. void ImpostaPartenzaEscursione( ESCURSIONE *e, const char *partenza );
  24. void ImpostaArrivoEscursione( ESCURSIONE *e, const char *arrivo );
  25. void ImpostaTempoEscursione( ESCURSIONE *e, unsigned int h, unsigned int m );
  26. void ImpostaDistanzaEscursione( ESCURSIONE *e, double km );
  27.  
  28. void StampaEscursione( ESCURSIONE *e );
  29.  
  30. #endif // ESCURSIONE_H


File escursione.c

Codice sorgente - presumibilmente C++
  1. #include "escursione.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <math.h>
  6.  
  7. /*==============================================================================
  8. Alloca dinamicamente una struttura di tipo ESCURSIONE impostata interamente su
  9. zeri e ne restituisce il puntatore. In caso di fallimento restituisce NULL.
  10. ==============================================================================*/
  11.  
  12. ESCURSIONE *CreaEscursione( void ) {
  13.     return calloc( 1, sizeof(ESCURSIONE) );
  14. }
  15.  
  16. /*==============================================================================
  17. Distrugge una struttura di tipo ESCURSIONE precedentemente allocata in memoria
  18. dinamica e ne imposta il puntatore su NULL.
  19. ==============================================================================*/
  20.  
  21. void DistruggiEscursione( ESCURSIONE **e ) {
  22.     if( e ) { free( *e ); *e = NULL; }
  23. }
  24.  
  25. /*==============================================================================
  26. Aggiunge in cima all'array esc il puntatore ad una struttura di tipo ESCURSIONE
  27. appositamente allocata in memoria dinamica e aggiorna il contatore dei puntatori
  28. contenuti nell'array. Se l'aggiunta va a buon fine restituisce 0; in caso
  29. contrario restituisce un codice di errore.
  30. ==============================================================================*/
  31.  
  32. int AggiungiEscursione( ESCURSIONE **esc, unsigned int *qEsc ) {
  33.     if( esc != NULL && qEsc != NULL ) {
  34.         if( *qEsc < QMAXESC ) {
  35.             esc[*qEsc] = CreaEscursione();
  36.             if( esc[*qEsc] != NULL ) {
  37.                 ++(*qEsc);
  38.                 return 0;       // tutto bene!
  39.             } else return 3;    // allocazione fallita
  40.         } else return 2;        // array saturo
  41.     } else return 1;            // parametro non valido
  42. }
  43.  
  44. /*==============================================================================
  45. Elimina dalla cima dell'array esc il puntatore ad una struttura di tipo
  46. ESCURSIONE appositamente allocata in memoria dinamica e aggiorna il contatore
  47. dei puntatori contenuti nell'array.
  48. ==============================================================================*/
  49.  
  50. void EliminaEscursione( ESCURSIONE **esc, unsigned int *qEsc ) {
  51.     if( *qEsc > 0 ) DistruggiEscursione( &esc[--*qEsc] );
  52. }
  53.  
  54. /*==============================================================================
  55. Imposta tutti i campi della struttura di tipo ESCURSIONE coerentemente coi
  56. parametri passati.
  57. ==============================================================================*/
  58.  
  59. void ImpostaEscursione( ESCURSIONE *e,
  60.     const char *partenza, const char *arrivo,
  61.     double km, unsigned int h, unsigned int m ) {
  62.     ImpostaPartenzaEscursione( e, partenza );
  63.     ImpostaArrivoEscursione( e, arrivo );
  64.     ImpostaDistanzaEscursione( e, km );
  65.     ImpostaTempoEscursione( e, h, m );
  66. }
  67.  
  68. /*==============================================================================
  69. Funzione ausiliaria per ImpostaPartenzaEscursione() e ImpostaArrivoEscursione().
  70. ==============================================================================*/
  71.  
  72. void ImpostaStringa( char *dest, const char *orig ) {
  73.     if( dest != NULL && orig != NULL )
  74.         strncpy( dest, orig, LMAXSTR );
  75.     else if( dest != NULL ) *dest = '\0';
  76. }
  77.  
  78. /*==============================================================================
  79. Imposta il campo lp (luogo di partenza) della struttura ESCURSIONE, curando che
  80. non venga superato il limite imposto dalle dimensioni dello spazio disponibile.
  81. ==============================================================================*/
  82.  
  83. void ImpostaPartenzaEscursione( ESCURSIONE *e, const char *partenza ) {
  84.     ImpostaStringa( e->lp, partenza );
  85. }
  86.  
  87. /*==============================================================================
  88. Imposta il campo la (luogo di arrivo) della struttura ESCURSIONE, curando che
  89. non venga superato il limite imposto dalle dimensioni dello spazio disponibile.
  90. ==============================================================================*/
  91.  
  92. void ImpostaArrivoEscursione( ESCURSIONE *e, const char *arrivo ) {
  93.     ImpostaStringa( e->la, arrivo );
  94. }
  95.  
  96. /*==============================================================================
  97. Imposta il campo t (tempo) della struttura ESCURSIONE, "accorpando" i valori
  98. delle ore e dei minuti.
  99. ==============================================================================*/
  100.  
  101. void ImpostaTempoEscursione( ESCURSIONE *e, unsigned int h, unsigned int m ) {
  102.     if( e != NULL ) e->t = h*60 + m;
  103. }
  104.  
  105. /*==============================================================================
  106. Imposta il campo d (distanza) della struttura ESCURSIONE, trasformando in
  107. metri la quantita' dei km passata. Le quantita' inferiori al metro sono soggette
  108. a un processo d'arrotondamento.
  109. ==============================================================================*/
  110.  
  111. void ImpostaDistanzaEscursione( ESCURSIONE *e, double km ) {
  112.     if( e != NULL ) {
  113.         if( km < 0.0 ) km = -km;
  114.         e->d = round( km*1000.0 );
  115.     }
  116. }
  117.  
  118. /*==============================================================================
  119. Visualizza in console il contenuto della struttura ESCURSIONE.
  120. ==============================================================================*/
  121.  
  122. void StampaEscursione( ESCURSIONE *e ) {
  123.     if( e != NULL ) {
  124.         unsigned int ore = e->t/60;
  125.         unsigned int min = e->t%60;
  126.         const char ps1[4] = "ea";
  127.         const char ps2[4] = "io";
  128.         printf( "Partenza: %s\n", e->lp );
  129.         printf( "Arrivo:   %s\n", e->la );
  130.         printf( "Distanza: %.2lf km\n", ((double)e->d)/1000.0 );
  131.         printf( "Tempo:    %u or%c", ore, ps1[ore==1] );
  132.         if( min ) printf( " e %u minut%c", min, ps2[min==1] );
  133.         printf( "\n" );
  134.     }
  135.     else {
  136.         printf( "Escursione non valida\n" );
  137.     }
  138. }


Il file escursione.c è in effetti un po' lunghetto, però "isola" alcuni procedimenti in un file "a parte", cosicché uno possa poi pensare al resto delle operazioni con un po' più leggerezza. Ad esempio...

File main.c:

Codice sorgente - presumibilmente C++
  1. #include <stdlib.h>
  2. #include <string.h>
  3. #include <stdio.h>
  4. #include "escursione.h"
  5.  
  6. int main() {
  7.     ESCURSIONE *esc[QMAXESC]; // array di puntatori a strutture ESCURSIONE
  8.     unsigned int i, qEsc = 0; // qEsc = quantita' di escursioni
  9.     int errore = 0; // zero: nessun errore
  10.  
  11.     memset( esc, 0, sizeof(ESCURSIONE*)*QMAXESC );
  12.  
  13.     for( i=0; i<3 && !errore; ++i )
  14.         errore = AggiungiEscursione( esc, &qEsc );
  15.  
  16.     if( !errore ) {
  17.         ImpostaEscursione( esc[0], "Palermo", "Trento", 1632, 1, 15 );
  18.         ImpostaEscursione( esc[1], "Olbia", "Vieste", 600.5, 6, 45 );
  19.         ImpostaEscursione( esc[2], "Loano", "Pietra Ligure", 0.5, 0, 5 );
  20.  
  21.         for( i=0; i<qEsc; ++i ) {
  22.             StampaEscursione( esc[i] );
  23.             printf( "\n" );
  24.         }
  25.  
  26.         while( qEsc != 0 )
  27.             EliminaEscursione( esc, &qEsc );
  28.     }
  29.  
  30.     return 0;
  31. }

ATTENZIONE! Sono un hobbista e l'affidabilità delle mie conoscenze informatiche è molto limitata. Non prendere come esempio il codice che scrivo, perché non ho alcuna formazione accademica e rischieresti di apprendere pratiche controproducenti.
PM
Avatar
Djot (Normal User)
Rookie


Messaggi: 28
Iscritto: 14/02/2017

Segnala al moderatore
Postato alle 15:33
Giovedì, 16/02/2017
Grazie mille a tutti per l'attenzione , ho trovato molto utili i vostri consigli , comunque ho provato a riscrivere il codice in questo formato :
Codice sorgente - presumibilmente C++
  1. #include <iostream>
  2. using namespace std;
  3. char const lenght = 20;
  4.  
  5. struct Escursione{
  6.         char luogoPartenza[lenght];
  7.         char luogoArrivo[lenght];
  8.         int distanza;
  9.         int tempo;
  10. }e;
  11.  
  12. struct NodoLista{
  13.         Escursione val;
  14.         NodoLista *next;
  15. }l;
  16.  
  17. struct NodoLista *crea_lista(){
  18.         typedef NodoLista* ptr_lista;
  19.         ptr_lista head , p;
  20.         int i , n;
  21.         cin >> n;
  22.         if(n==0)
  23.                 head = NULL;
  24.         else{
  25.                 cin >> head->val.luogoPartenza >> head->val.luogoArrivo >> head->val.distanza >> head->val.tempo;
  26.                 p = head->next;
  27.         for(i=0;i<n;i++){
  28.                 p=p->next;
  29.                 cin >> p->val.luogoPartenza >> p->val.luogoArrivo >> p->val.distanza >> p->val.tempo;;
  30.         }
  31. }
  32.         p->next = NULL;
  33.         return (head);
  34. }
  35.  
  36. void stampa_lista(struct NodoLista *p , struct NodoLista *head){
  37.         while(head!=NULL)
  38.                 cout << head->val.luogoPartenza << head->val.luogoArrivo << head->val.distanza << head->val.tempo;;
  39.         head = head->next;
  40. }
  41.  
  42. void ricerca_lista(struct NodoLista *p , struct NodoLista *head){
  43.         int i;
  44.         cin >> i;
  45.         while(head->val.distanza!=i){
  46.                 head=head->next;
  47.                 cout << head->val.distanza;
  48.         }
  49. }
  50. int main(){
  51.         struct NodoLista crea_lista();
  52.         void stampa_lista(struct NodoLista *p , struct NodoLista *head);
  53.         void ricerca_lista(struct NodoLista *p , struct NodoLista *head);
  54.         return 0;
  55. }


Potete darmi una correzione anche di questo?
Grazie mille per l'attenzione.

PM
Avatar
TheDarkJuster (Member)
Guru^2


Messaggi: 1620
Iscritto: 27/09/2013

Segnala al moderatore
Postato alle 17:58
Giovedì, 16/02/2017
Il tuo ultimo codice non ha molto senso... Non alloca memoria... La usa senza averne il permesso. Se anche si compilasse (hai provato?) terminerebbe in malomodo con un segmentation fault. Inoltre non riesco bene a capire il senso del crea_lista.

PM
Avatar
Djot (Normal User)
Rookie


Messaggi: 28
Iscritto: 14/02/2017

Segnala al moderatore
Postato alle 18:15
Giovedì, 16/02/2017
Con crea_lista avevo intenzione di definire la lista delle escursioni , per allocazione di memoria intendi la keyword malloc? Non capisco per quale motivo ma il compilatore segna errore ogni volta che provo ad introdurla , nonostante abbia provato varie librerie

PM
Avatar
lumo (Member)
Expert


Messaggi: 449
Iscritto: 18/04/2010

Segnala al moderatore
Postato alle 18:30
Giovedì, 16/02/2017
Malloc non è una keyword bensì una funzione, e la puoi usare solo dopo aver incluso <cstdlib> (o <stdlib.h> in C).

Il codice continua ad avere errori veramente banali, sicuro di aver studiato le funzioni? E almeno un minimo i puntatori?
Oltre agli errori di base ci sono anche errori concettuali, tipo prendere dati da input nella funzione di ricerca, dovresti passare la cosa da cercare come parametro della funzione.
Hai del codice a cui fare riferimento? Perché o è sbagliato quello, oppure stai andando completamente a caso sperando che funzioni.

PM
Pagine: [ 1 2 3 ] Precedente | Prossimo