[C]Problema strutture ricorsive

[Iso90]

Ciao a tutti! Ecco il mio problema:

-Questa è la struttura in questione:

typedef struct lista_elem
{
     int value;
     struct lista *next;
}lista_elem_t;

-Questo è il codice per creare la lista di elementi dove ad ogni elementi viene assegnato un intero crescente:

    lista_elem_t *elem;
    lista_elem_t *p;

    p=(vertice_grafo_t *)malloc(sizeof(vertice_grafo_t));
    /*testa lista*/
    elem = p;
    for(i=0;i<NUM;i++)
    {
            p->code = i;
            p->next=(lista_elem_t *)malloc(sizeof(lista_elem_t));
            p = p->next;
 
    }

-Poi ho provato a stamparli in questo modo:

    int i=0;
    
    while(i<NUM)
    {
        p=elem;
        printf("Code: %d\n", p->code);
        p=p->next;
        i++;
    }

L'output a video sono tutti zeri invece di 0,1,2,...,NUM-1. Dove sbaglio??

[shodan]

p = elem dev'essere esterno al while.

[Iso90]

Grazie mille!

PS: per rendre più genercio possibile il tutto ho voluto sostisuire il while con un for sugli indirizzi:

    for(p=elem;p!=NULL;p=p->next)
    {
        printf("Code: %d\n", p->code);
    }

Compila correttamente ma al lancio dell'applicazione stampa tutti i valori, sfora in un indirizzo ignoto, lo stampa e poi crasha, perchè?

[shodan]

Perché in fase di inserimento dei valori non metti l'ultimo elemento della lista a NULL.
Dovrebbe essere sufficente inserire come ultma istruzione del for()
p->next = NULL

[Iso90]

Ho provato a inserire quella riga qui:

    lista_elem_t *elem;
    lista_elem_t *p;

    p=(vertice_grafo_t *)malloc(sizeof(vertice_grafo_t));
    /*testa lista*/
    elem = p;
    for(i=0;i<NUM;i++)
    {
            p->code = i;
            p->next=(lista_elem_t *)malloc(sizeof(lista_elem_t));
            p = p->next;
            p->next = NULL; /* <==========INSERITO QUI*/
 
    }

Il risultato è che non crasha più però stampa un numero fuori dai limiti, ES: 0,1,2,3,4,5,6,15487621.
Si può rimediare?

[Iso90]

Ho fatto qualche prova ed alla fine sono giungo qua:

    lista_elem_t *elem;
    lista_elem_t *p;

    p=(lista_elem_t *)malloc(sizeof(lista_elem_t));
    /*testa lista*/
    elem = p;
    for(i=0;i<NUM;i++)
    {

            p->next=(lista_elem_t *)malloc(sizeof(lista_elem_t));
            p = p->next;
            p->code = i;
            p->next = NULL;
 
    }

/*STAMPA STRUTTURA*/ 
    for(p = elem->next; p != NULL; p = p->next)
    {
        printf("Code: %d\n", p->code);
    }

Così facendo ho fatto in modo che la testa della lista sia composta solo da un puntatore al primo vero elemento, e quando vado a scorrere la lista per un qualsiasi uso (in questo caso la stmpa) parto dal secondo elemento inizializzando p = elem->next.
E' una cosa che può andare bene o è un insulto al linguaggio C?

[c0der]

Mi sono permesso di sistemarti il codice, con il problema della testa, ciao.

#include <stdio.h>
#include <stdlib.h>

#define NUM 10

struct lista_elem {
    int code;
    struct lista_elem *next;
};

typedef struct lista_elem lista_elem_t;

int main()
{
    lista_elem_t *testa, *p;
    int i;

    testa = p = (lista_elem_t *)malloc(sizeof(lista_elem_t));
    p->code = 0;
    
    for (i = 1; i < NUM; i++) {
        p->next = (lista_elem_t *)malloc(sizeof(lista_elem_t));
        p = p->next;
        p->code = i;
        p->next = NULL;
    }

    for (p = testa; p != NULL; p = p->next)
        printf("code: %d\n", p->code);

    return 0;
}

[Iso90]

Originariamente inviato da c0der

Loso anche io avevo pensato di fare una cosa del genere però così il primo elemento della lista avrà sempre il valore 0.
Io qua ho semplificato la struttura ed il codice, ed in realtà nel mio caso il modello in cui il primo elemento della lista abbia valore 0 ,sempre e comunque, va stretto!

[c0der]

Ho messo 0 ma puoi mettere quello che vuoi, sostituendo:
p->code = 0;
con
p->code = altro_valore_o_valore_di_ritorno_funzione_o_altra_ variabile;
Non vedo il problema.

[Iso90]

Hai ragione!!! Grazie mille!