[C] Non riesco a capire alcune cose sulle code

[-Ivan-]

Scusate ma non riesco proprio a capire questo codice sulle code.
Allora il codice seguente l'ha scritto il mio prof di programmazione.

struct cella
{
    int valore;
    struct cella *next;
};

struct wrapperCoda
{
    struct cella *ptrTesta;
    struct cella *ptrCoda;
};

int creaElemento(struct wrapperCoda *c, int num);
void stampaCoda(struct wrapperCoda c);
int cercaInCoda(struct wrapperCoda c, int numero);
int eliminaElemento(struct wrapperCoda *c, int num);
void resetCoda(struct wrapperCoda *c);

int main()
{
    struct wrapperCoda coda ;
    coda.ptrTesta = NULL;
    coda.ptrCoda = NULL;
}

void resetCoda(struct wrapperCoda *c)
{
    struct cella *temp;
    
    while ((*c).ptrCoda != NULL)
    {
        temp = (*c).ptrCoda;
        (*c).ptrCoda = (*c).ptrCoda->next;
        free(temp);
    }
    c->ptrTesta = NULL;    
}

/*
restituisce 1 se l'elemento è stato eliminato, 0 altrimenti
*/
int eliminaElemento(struct wrapperCoda *c, int num)
{
    struct cella *prec, *temp;
    
    temp = (*c).ptrCoda;
    prec = NULL;
    
    while (temp != NULL)
    {
        if (temp->valore == num)
        {
            if (prec == NULL)
                (*c).ptrCoda = (*c).ptrCoda->next;
            else
            {
                prec->next = temp->next;
                if (prec->next == NULL)
                    (*c).ptrTesta = prec;
            }    
            free(temp);
            return 1;
        }
        prec = temp;
        temp = temp->next;
    } 
    
    return 0;
}

/*
viene restituito 1 se l'elemento è stato inserito, 0 se l'elemento è già presente in coda
*/
int creaElemento(struct wrapperCoda *c, int num)
{
    struct cella *nuovoElemento;
    
    if (cercaInCoda(*c,num) == 0)
    {
        nuovoElemento = (struct cella*)malloc(sizeof(struct cella));
        if (nuovoElemento == NULL)
        {
            printf("\n\n Errore nell\'allocazione della memoria.\n Il programma verra\' chiuso!\n ");
            system("pause");                    
            exit(1);
        }
        nuovoElemento->valore = num;
        nuovoElemento->next = NULL; 
        if ((*c).ptrTesta != NULL)
            (*c).ptrTesta->next = nuovoElemento;
        else
            (*c).ptrCoda = nuovoElemento;
        (*c).ptrTesta = nuovoElemento;
        return 1;
    }    
    else
        return 0;
}

Ho tagliato i pezzi che non mi interessavano, analizzando le funzioni non capisco le seguenti cose:

1) Quando viene creata la lista, diciamo una lista di 5 elementi
struct cella *ptrTesta e struct cella *ptrCoda che sono elementi del wrapper a cosa puntano? (dal nome direi testa al primo elemento e coda all'ultimo ma non capisco perchè).
2) Il ciclo che elimina la coda a guardare il codice mi sembra che cancelli gli elementi a partire dall'ultimo, invece quando uso il codice in un programma mi cancella dal primo.

[andbin]

Originariamente inviato da -Ivan-

Scusate ma non riesco proprio a capire questo codice sulle code.
Allora il codice seguente l'ha scritto il mio prof di programmazione.

Ma il tuo prof è un genio se riesce a scrivere:

(*c).ptrCoda

invece di

c->ptrCoda

(io ce l'ho un pochino con i prof perché mi hanno rovinato la carriera... mica per altro)

P.S. adesso leggo bene il codice e ti dico.

[andbin]

Originariamente inviato da -Ivan-

1) Quando viene creata la lista, diciamo una lista di 5 elementi
struct cella *ptrTesta e struct cella *ptrCoda che sono elementi del wrapper a cosa puntano? (dal nome direi testa al primo elemento e coda all'ultimo ma non capisco perchè).
2) Il ciclo che elimina la coda a guardare il codice mi sembra che cancelli gli elementi a partire dall'ultimo, invece quando uso il codice in un programma mi cancella dal primo.

Semplice ... le due variabili sono gestite al "contrario". ptrTesta punta sempre all'ultimo elemento inserito mentre ptrCoda punta al primo elemento inserito.

Piuttosto (non avendo tutto il sorgente completo):

if (cercaInCoda(*c,num) == 0)

così gli passa la struttura per valore. Che gli serve a fare?

Dai ... 10 e lode al prof e non ne parliamo più

[-Ivan-]

Originariamente inviato da andbin

Semplice ... le due variabili sono gestite al "contrario". ptrTesta punta sempre all'ultimo elemento inserito mentre ptrCoda punta al primo elemento inserito.

Piuttosto (non avendo tutto il sorgente completo):

if (cercaInCoda(*c,num) == 0)

così gli passa la struttura per valore. Che gli serve a fare?

Dai ... 10 e lode al prof e non ne parliamo più

Porca pupazza ecco io davo quasi per scontato che testa puntasse al primo e code all'ultimo e questo mi faceva partire con i "pregiudizi" nella lettura del codice.
Dio sto schiattando non ci capisco più una mazza tra code pile e alberi qualcuno mi salvi.
Grazie come al solito delle risposte .

[sottovento]

Come sempre andbin ha dato una risposta impeccabile.

Direi che quel codice e' davvero strano, e mi sembra impossibile che sia stato scritto da un professore. Oltretutto doveva essere codice con uno scopo didattico...

E' davvero difficile pensare che questo codice sia stato scritto per la gestione di una coda, non essendo nemmeno una lista bidirezionale. Il fatto che memorizzi l'elemento di coda non importa a nessuno. Inoltre l'inserimento non avviene ad un estremo, come d'altronde la cancellazione.

Proprio strano. Tienici informati

High Flying
Sottovento

[cj++]

Originariamente inviato da andbin

Ma il tuo prof è un genio se riesce a scrivere:
(*c).ptrCoda invece di c->ptrCoda

Questo è niente. Io ho avuto chi scriveva
*((*((*(myArray+i))+j))+k)
invece di myArray[i][j][k]

[andbin]

Originariamente inviato da cj++

Questo è niente. Io ho avuto chi scriveva
*((*((*(myArray+i))+j))+k)
invece di myArray[i][j][k]

Per carità!!! Se qualche mio collega facesse una cosa del genere in un sorgente C allora ...
uaaataaaa! lo spiezzo in due, compresa la tastiera

[-Ivan-]

Originariamente inviato da sottovento

Come sempre andbin ha dato una risposta impeccabile.

Direi che quel codice e' davvero strano, e mi sembra impossibile che sia stato scritto da un professore. Oltretutto doveva essere codice con uno scopo didattico...

E' davvero difficile pensare che questo codice sia stato scritto per la gestione di una coda, non essendo nemmeno una lista bidirezionale. Il fatto che memorizzi l'elemento di coda non importa a nessuno. Inoltre l'inserimento non avviene ad un estremo, come d'altronde la cancellazione.

Proprio strano. Tienici informati

High Flying
Sottovento

E' stato scritto dal mio prof di programmazione, il problema è che io l'ho usato circa uguale nel mio progetto e adesso mi si stanno complicando le cose.
Non vi faccio vedere il codice per le pile ma anche quello mi sta dando dei bei problemi.

[leadergl]

io non capisco perchè per gestire la struttura delle code che è la più semplice al mondo il tuo prof. abbia usato i puntatori...

sono sempre stato abituato ad usare le code per un numero finito di elementi, altrimenti non sarebbe una coda...nel senso che una coda prima o poi si riempie quindi sappiamo a priori quanti elementi dovrebbe contenere, di conseguenza mi viene spontaneo pensarla come una "struttura" che non fa altro che gestire in maniera particolare un vettore; ovvero gestirlo in maniera circolare!

[andbin]

Ecco una bella gestione di una coda usando un array invece di una lista. Spero possa esservi utile.

[nightfly]

Il codice è macchinoso e poco chiaro... è evidente che lo scopo di tale esempio non è illustrativo o tantomeno didattico... l'unica cosa che risulta chiara sono l'inizializzazione della testa e delle coda (che identificano la pila) a null poichè originariamente la pila si suppone vuota... oltre alle diverse funzioni che implementano le varie operazioni da eseguire su di essa (cancellazione, inserimento ecc ecc). Peccato per i body di ciascuna di esse, praticamente incomprensibile. Dici al tuo prof di iniziare a leggere il significato degli operatori booleani e non, e dopo, eventualmente, di proporti un esempio del genere Saluti.

[-Ivan-]

Infatti io all'iti ricordo che le pile e le code non mi davano problemi però ora non ci capisco più niente.
Porca miseria visto che ci siamo:
una pila può essere stampata senza che venga svuotata?

questa è la funzione che la stampa fatta dal mio prof:

void stampaPila(struct cella **t)
{
    struct cella *temp;
    
    printf("\n");
    if (t == NULL)
    {
        printf(" La pila e\' vuota!\n");
        return;
    }
    
    do
    {
        temp = pop(t);
        printf(" valore: %d\n",temp->valore);
        free(temp);
    } (*t != NULL); 
}
struct cella * pop(struct cella **t)
{
    struct cella *temp;

    if (*t == NULL)
        return NULL;
    temp = *t;
    *t = (*t)->next;
    temp->next = NULL; 
    return temp;
}

La pila contiene solo un campo int valore e il puntatore next.
t è una variabile di tipo cella.
Ho tre giorni per finire il progetto e sono messo veramente male.

[andbin]

Originariamente inviato da -Ivan-

una pila può essere stampata senza che venga svuotata?

Beh, certo. È solo questione di studiare come accedere alla pila senza fare casini sul contenuto.

Originariamente inviato da -Ivan-

questa è la funzione che la stampa fatta dal mio prof:

...

A ridaje con il codice del prof ...
Non capisco la necessità del doppio puntatore struct cella **t (non ho il codice completo, comunque) e non capisco perché si debba eseguire una funzione pop() per stampare i dati in una pila se non la si vuole svuotare!

[DanieleC88]

Originariamente inviato da cj++

Questo è niente. Io ho avuto chi scriveva
*((*((*(myArray+i))+j))+k)
invece di myArray[i][j][k]

Coding HORROR!
Dovresti farlo partecipare all'OCCC.

[andbin]

Originariamente inviato da DanieleC88

Dovresti farlo partecipare all'OCCC.

IOCCC, "International Obfuscated C Code Contest", www.ioccc.org

Indubbiamente, uno che scrive *((*((*(myArray+i))+j))+k) ha molte buone possibilità di vincere, specialmente nella categoria "Abuse of the rules".

[DanieleC88]

Originariamente inviato da andbin

IOCCC, "International Obfuscated C Code Contest", www.ioccc.org

Ah, avevo dimenticato la I... e vabbe', tutti posso sbagliare.

Originariamente inviato da andbin

Indubbiamente, uno che scrive *((*((*(myArray+i))+j))+k) ha molte buone possibilità di vincere, specialmente nella categoria "Abuse of the rules".

Appunto!

[-Ivan-]

Forse il mio prof ha intenzione di farci partecipare tutti e ci sta preparando in segreto.
Si spiega tutto adesso.
Tra poco metterò mano agli alberi...ho paura .