Struct

struct autom{
   int targa;
   int strada_arrivo;
};

struct rotatoria{
   struct autom * autom_rot;
   int posizione;
   struct rotatoria * next;
};

struct coda{
   struct autom * auto_strada;
   struct coda * next;
   struct coda * testa;
   struct coda * ultimo;
   struct rotatoria * collegamento;
};

struct strada{
   int nome;
   struct coda *attesa;
};

struct istante{
   struct rotatoria * rotat_ist;
   struct strada * stradat[5];
   int momento;
};


struct rotatoria* crearotatoria()
{
    struct rotatoria *p,*t;
    int i;

    t = NULL;
    for( i = 0; i < 15; i++)
    {
        p = malloc( sizeof(struct rotatoria) );
        p->autom_rot = malloc( sizeof(struct autom) );
        p->autom_rot->targa = 0;
        p->autom_rot->strada_arrivo = 0;
        p->posizione = 14-i;
        p->next = t;
        t = p;
    }

    return t;
}

int metti_in_rotonda(struct rotatoria* rot,int targa, int pos_e, int str_u)
{
    if(rot->posizione == pos_e)
    {
        if(rot->autom_rot->targa == 0)
        {
            rot->autom_rot->targa = targa;
            rot->autom_rot->strada_arrivo = str_u;
            return 1;
        }
        else
            return 0;
    }
    else
    {
        //return metti_in_rotonda(rot->next, targa, pos_e, str_u);
        //se pos_e non corrisponde inneschi una ricorsione infinita.(per quello ho tolto la lista circolare)
        return (rot->next) ? metti_in_rotonda(rot->next, targa, pos_e, str_u) : 0;
    }
}

struct coda* crea(int targa,int uscita)
{
    struct coda* appoggio = malloc( sizeof(struct coda) );
                 appoggio->auto_strada = malloc( sizeof(struct autom) );
                 appoggio->auto_strada->targa = targa;
                 appoggio->auto_strada->strada_arrivo = uscita;
                 appoggio->next=NULL;
                 appoggio->collegamento = malloc(sizeof(struct rotatoria));
    return appoggio;
}

struct coda* ins_coda(struct coda* via,int targa,int strada_u)
{
    if( !via )
        return crea(targa,strada_u);

    struct coda* l;
    for ( l = via; l->next ; l = l->next);
    l->next = crea(targa,strada_u);

    return via;
}




int main(int argc, char *argv[])
{
   //HANDLE hConsole;
   //hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
    int c;
    int cont_macc_rot = 0;//variabile usata per sapere il numero di macchine presenti sulla rotonda
    int targa;//variabile usate per leggere da file la targa dell auto
    int posizione_e;//variabile usata per leggere da file dove si trova l' auto inizialmente
    int strada_u;//variabile usata per indicare la strada di uscita che l' auto vuole prendere

    struct istante* iniziale = malloc( sizeof(struct istante) );
    //iniziale->rotat_ist = (struct rotatoria*) malloc(sizeof(struct rotatoria));

    for( c = 0 ; c < 5 ; c++ )
    {
        iniziale->stradat[c] = malloc(sizeof(struct strada));
        iniziale->stradat[c]->nome = c;
        iniziale->stradat[c]->attesa =  malloc(sizeof(struct coda ));
        iniziale->stradat[c]->attesa->collegamento = malloc(sizeof(struct coda));
    }

    iniziale->rotat_ist = crearotatoria();


    FILE* file = fopen ("macchine.txt","r");
        if ( !file )
        {
            //qui sarebbe carino liberare la memoria
            fputs ("File impossibile da aprire\n",stderr);
            return -1;
        }

    while( !feof(file) )
    {
        if ( (fscanf(file,"%d" ,&targa)>=0) &&(fscanf(file,"%d",&posizione_e)>=0) && (fscanf(file,"%d",&strada_u)>=0))
        {
            if ( (posizione_e >= 0) && (posizione_e < 15) && (cont_macc_rot <= 15) && (targa != 0))
            {
               printf("\n%d",posizione_e);
               if( !metti_in_rotonda(iniziale->rotat_ist, targa, posizione_e, strada_u ) )
                  printf("macchina con targa: %d non inserita perche la posizione %d e' gia' occupata",targa,posizione_e);
               else
                  cont_macc_rot++;

            }

            if( (posizione_e >= 15) && (posizione_e < 19) && (targa != 0))
            {
                switch(posizione_e)
                {
                    case 15:
                        iniziale->stradat[0]->attesa = ins_coda(iniziale->stradat[0]->attesa,targa,strada_u);
                    break;
                    case 16:
                        iniziale->stradat[1]->attesa = ins_coda(iniziale->stradat[1]->attesa,targa,strada_u);
                    break;
                    case 17:
                        iniziale->stradat[2]->attesa = ins_coda(iniziale->stradat[2]->attesa,targa,strada_u);
                    break;
                    case 18:
                        iniziale->stradat[3]->attesa= ins_coda(iniziale->stradat[3]->attesa,targa,strada_u);
                    break;
                    case 19:
                        iniziale->stradat[4]->attesa = ins_coda(iniziale->stradat[4]->attesa,targa,strada_u);
                    break;
                }
            }
        }//if read scanf
    }//while

    printf("\n");
    fclose(file);

    return 0;
}
Il codice cosi è corretto.
Non ho controllato però la logica del programma,ovvero ho tolto solo gli errori di programmazione ma non quelli di logica perchè non conosco cosa debba fare il programma,e il contenuto del file.La logica che usi è un pò contorta ma come detto non conoscendo l'esercizio è difficile valutare.
Se continua a non funzionare allora dovrai spiegare cosa deve fare il programma e cosa contiene il file.
15 Risposte - Pagina 2

Re: Struct
