Newsgroup: it.comp.lang.c
Titolo: vettori e strutture

Salve, ho un problema...
Voglio creare una struttura che contenga un vettore di interi (dimensione
fissa) e altri campi, tipo questa:
struct test {
    int data[100];
    int x, y;
}
ora, quando voglio inizializzare il vettore data[] come facio?
Se faccio cosě:
void init(struct test **t) {
    struct test *tt;
    tt=(struct test *)malloc(sizeof test));
    tt=*t;
}
    e poi accedo a t->data[1] non mi lascia, nel senso che mi esegue
l'istruzione e DOPO coredumpa!
    Ho pensato che prima forse dovrei allocare anche il vettore (anche se
sizeof(struct test) dovrebbe tenerne conto) ma non so...
Come diavolo si fa??
Grazie,
Tom.

}
dovrebbe essere il contrario a quanto so .... *t = tt;

    tt = *t;
----^
e qui un '*' mancante?
C:\>iao Angelo

e qui un '*' mancante?
No ... è solo l'assegnazione che è alla rovescia ... sono due
puntatori che si passano un indirizzo, tutto qua.
Ciao.

 wrote in message
j74rjukr830pidagk...@4ax.com...



Non posso prevedere il comportamento di un codice a priori ... fatto
sta che fai un'assegnazione sbagliata, t non ha un valore corretto e
per giunta tenti di accedere ad uno dei suoi membri ... credo che piů
sbagliato di cosě ... 
Francamente non ricordo se devi assegnare memoria anche al vettore
(per sicurezza, guardati che valore restituisce sizeof), ma
sicuramente " tt = *t " č un'assegnazione non valida ...
Infatti, oltre a dereferenziare in seguito in modo errato, perdi anche
l'indirizzo di memoria che la malloc ti ha tanto faticosamente :-)
restituito.

 }
void init(struct test **ppt)
{
     *ppt = malloc(sizeof **ppt);
}

 Ti assicuro che cosě funziona, l'ho usata per altri algoritmi
Come fa a funzionare? Crei una variabile locale (tt); con malloc, poi, crei
lo spazio e assegni a tt l'indirizzo dello spazio creato. Infine modifichi
questo indirizzo con il valore passato alla funzione. Che senso ha aver
creato questo spazio se, poi, il suo indirizzo lo butti al vento? Che senso
ha assegnare a tt un indirizzo se poi all'uscita dalla funzione questa
variabile non esiste piů?
Cosě funziona bene:
    void init(struct test **t) {
       struct test *tt;
       tt = malloc(sizeof(struct test));
       *t = tt;
       // verifica
       tt->data[0] = 43;
       tt->x = 15;
       tt->y = 17;
    }
    int main(void) {
       struct test *p;
       init(&p);
       printf("init -> data[0] = %d x = %d y = %d\n", p->data[0], p->x,
p->y);
       return 0;
    }
Maurizio.

 sizeof(struct test) dovrebbe tenerne conto) ma non so...
 Se fai tt=malloc.... stai riservando memoria per tt . Poi fai tt=*t. quindi
la memoria que hai riservato prima rimane persa nell'universo. tt sta
puntando adesso dove punta *t. Posso indovinare che nel main() hai fatto
qualcosa come:
struct test *t;
init(&t);
Vuol dire che t punta a NULL. Allora tt puntera non so dove, e quando fai
t->data, stai puntando a NULL. Risultato: Core dumped.
Vale a dire che quando fai malloc stai riservando spazio per una intera
struttura, anche per i 100 interi.
Devi fare, come dice Caldaia, *t=tt.
Toni


 Devi fare, come dice Caldaia, *t=tt.
Non capisco perche' bisogna complicarsi la vita a questo modo.
Come ho gia' scritto nel mio messaggio, se ho:
int main()
{
    int *p;
}
e voglio passare p ad una funzione per riferimento, allora scrivero':
int main()
{
    int *p;
    myfunc(&p);
}
La funzione dovra' quindi accettare un puntatore a puntatore a intero:
void myfunc(int **p)
{
     /* ... */
}
int main()
{
    int *p;
    myfunc(&p);
}
Ora, se nella funzione voglio far si' che il puntatore passato venga
valorizzato, allora mi basta scrivere:
void myfunc(int **p)
{
     *p = malloc(10 * sizeof **p);
}
int main()
{
    int *p;
    myfunc(&p);
}
Il tutto senza assegnamenti strani.