[C] strutture

[gepeppe]

salve, ho dichiarato una struttura di questo tipo:

struct elementi {
	char *w;
};

poi nel main

struct elementi *str;

per creare un array di strutture dinamico.

cosi, alloco la memoria per gli elementi dell'array str, e nello stesso tempo poi alloca la memoria per ogni elemento str[i].w. Fin qui tutto bene. Ma se volessi liberare completamente la memoria occupata dalla struttura, come dovrei fare?? cioè sia quella occupata dinamicamente da ogni str[i].w e sia quella dell'array str dinamico.

grazie

[andbin]

Originariamente inviato da gepeppe

salve, ho dichiarato una struttura di questo tipo:

struct elementi {
	char *w;
};

poi nel main

struct elementi *str;

per creare un array di strutture dinamico.

Quindi allochi dinamicamente un array di struct elementi che assegni a 'str'.

Se vuoi liberare il tutto basta:
- fare una free di ogni singolo puntatore str[i].w (ammesso che tu abbia usato l'allocazione dinamica anche per queste aree di memoria)
- fare una free dell'intero array di strutture (free(str) in sostanza).

[gepeppe]

cioè un:

{
for(i = i; i<n, i++)
{free(str[i].w);}

free(str);

}

[gepeppe]

tornando alla struttura, ho un problema con realloc. Ho la struttura di dimensioni 10, e se la rialloco e poi vado a leggere gli elementi mi da errore:

struct elementi {
	char *w;
};

struct elementi *I;

int i;
//prima allocazione di 10 elementi
I=(struct elementi *)malloc(10*sizeof(struct elementi));

//alloco poi ogni elemento w
for(i= 0; i<10; i++){
I[i].w = (char *)malloc(10*sizeof(char));
}
//realloco la struttura per ampliarla	
I =(struct elementi *)realloc(I, 30);

//alloco ora i nuovi elementi della struttura
for(i= 10; i<30; i++){
	I[i].w = (char *)malloc(10*sizeof(char));
}
	
//la caricao tutta con il valore c
	for(i= 0; i<30; i++)
		strcpy(I[i].w, "c");

//vado a leggermi i valori	
	for(i= 0; i<30; i++)
	printf("%s\n", I[i].w);

e nell'ultimo passaggio mi da errore!!! perchè??

[gepeppe]

nessuno mi sà aiutare con la realloc dell'esempio?

[mjordan]

Usi la realloc() in modo completamente sbagliato. Nella malloc() allochi (se la matematica non è un'opinione) 40 byte su architettura x86 32 bit, nella realloc() invece, specifichi di ridimensionare il blocco puntato da I a 30 byte. Ne consegue che al posto di ottenere un maggioramento della memoria allocata, ne ottieni invece uno shrink, causando nei for() successivi dei buffer overflow che ti portano al segfault (e precisamente nella strcpy())
Devi quindi riallocare 120 byte in totale per avere il comportamento sperato.
Il programma corretto è quindi questo:

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

struct elementi {
	char *w;
};

struct elementi *I;

int main(void)
{
	int i;
        /* prima allocazione di 10 elementi */
	I = (struct elementi *)malloc(10*sizeof(struct elementi));

        /* alloco poi ogni elemento w */
        for(i = 0; i < 10; i++) {
		I[i].w = (char *)malloc(10*sizeof(char));
        }
        /* realloco la struttura per ampliarla */	
        I = (struct elementi *)realloc(I, 30* sizeof(struct elementi));

        /* alloco ora i nuovi elementi della struttura */
        for(i = 10; i < 30; i++) {
		I[i].w = (char *)malloc(10*sizeof(char));
        }
	
        /* la caricao tutta con il valore c */
	for(i = 0; i < 30; i++)
		strcpy(I[i].w, "c");

        /* vado a leggermi i valori */	
	for(i = 0; i < 30; i++)
		printf("%s\n", I[i].w);

	return 0;
}

Nota che ho lasciato il tuo codice il piu' invariato possibile (commenti inclusi) ma realloc() non "rialloca una struttura" bensi un blocco di memoria puntato da un puntatore. Inoltre tralascio la non verifica dei valori di ritorno delle varie funzioni (siamo pur sempre in un esempio, ma ce ne sarebbero di cose da dire).

[gepeppe]

Originariamente inviato da mjordan

Usi la realloc() in modo completamente sbagliato....

        /* realloco la struttura per ampliarla */	
        I = (struct elementi *)realloc(I, 30* sizeof(struct elementi));

Nota che ho lasciato il tuo codice il piu' invariato possibile (commenti inclusi) ma realloc() non "rialloca una struttura" bensi un blocco di memoria puntato da un puntatore. Inoltre tralascio la non verifica dei valori di ritorno delle varie funzioni (siamo pur sempre in un esempio, ma ce ne sarebbero di cose da dire).

Sbagliavo a scrivere la realloc..cavolo!!! Cmq come potrei fare per riallocare una struttura invece??
Ti ringrazio per la spiegazione

[gepeppe]

riscrivo la domanda in modo migliore. Ho una struttura come quella di prima, struct x; Mettiamo di avere una funzione che modifica la struttura

void modfy(struct x *p){
p -> dato = 3;
}

Mentre nel main ho una cosa del genere:

struct x valori;
modify(&valori);
printf("valore == $d\n", valori.dato);

passo alla funzione l'indirizzo della struttura, cosi che la modifica, e io nel main ho la struttura bella e modificata , infatti stampa 3. Ma se volessi fare lo stesso per un'array di strutture??
Cioè se nel main ho:

struct valori x[10];

come la passo alla funzione modfy, e nella funzione come accedo ai membri tramite il puntatore per modificare tutti i sui valori, cioè x[1].dato, x[2].dato ecc..?

[71104]

a parte che casomai sarebbe

struct x valori[10];

anziché

struct valori x[10];

... dipende da cosa deve fare esattamente la funzione modify: deve modificarle tutte e 10 o solo una? nel primo caso aggiungi un parametro che specifichi il numero di strutture nell'array e fai un for:

void modify(struct x *p, int count) {
	for (int i = 0; i < count; i++) {
		p[i].dato = 3;
	}
}

nel secondo caso invece basta che passi l'indirizzo della struct che vuoi modificare; metti che vuoi modificare la sesta, cioè quella con indice 5:

struct x valori[10];
modify(valori + 5);
printf("valore == $d\n", valori[5].dato);

oppure in alternativa:

struct x valori[10];
modify(&valori[5]);
printf("valore == $d\n", valori[5].dato);

[gepeppe]

no io voglio modificare nella funzione modify tutta la struttura, quindi nn posso passargli un solo valore. Inoltre se faccoi come hai detto tu, nella funzione modifico il valore locale della struttura, che non ritroverei all'uscita della stessa. Allora, facciamo cosi,

void modify(struct x *p, int count) {
	for (int i = 0; i < count; i++) {
		p[i] -> .dato = 3;
	}
}

void main(){
struct x valori[10];

modfy(valori);

	for (int i = 0; i <10; i++) {
		printf("%d\n", valori[i].a);
	}
}

Il programma non funziona, perchè?? io voglio passare alla funzione un puntatore alla struttura, in modo tale che la funzione modfy modifica la struttura, ma nel main ho la struttura modificata e posso mostrarne i valori...

[71104]

Originariamente inviato da gepeppe

Il programma non funziona, perchè??

più che altro non compila visto questo obbrobbrio sintattico:

		p[i] -> .dato = 3;

io voglio passare alla funzione un puntatore alla struttura, in modo tale che la funzione modfy modifica la struttura, ma nel main ho la struttura modificata e posso mostrarne i valori...

e il codice mio non andava bene? te lo riscrivo per intero:

struct x {
	int dato;
};

void modify(struct x *p, int count) {
	for (int i = 0; i < count; i++) {
		p[i].dato = 3;
	}
}

int main() {
	struct x valori[10];
	modify(valori, 10);
	printf("valore == %d\n", valori[5].dato);
	return 0;
}

[gepeppe]

l'istruzione p[i].a pensavo che fosse simile all'istruzione p.a, cioè pensavo che modificasse in locale il valore di a, come con l'operatore . mentre invece io volevo usare i puntatori..e credevo che ci soffe una cosa del gennere:
p -> a (se non fosse stata un array di strutture
p[n] -> (se fosse stato un array di strutture) - (l'obbrobbrio )

invece da quanto ho capito si deve fare p[n].a ....ho capito bene?

[71104]

Originariamente inviato da gepeppe

p[n] -> (se fosse stato un array di strutture) - (l'obbrobbrio )

p[n] -> a non è necessariamente un obbrobbrio: a seconda di come dichiari p ed n potrebbe essere perfettamente valido. una cosa che è sicuramente sbagliata invece è quella che hai fatto tu, ma più per errore ortografico credo:

p[i] -> .dato

è il punto dopo la freccia che non va: due operatori binari non possono stare uno appresso all'altro in C.

invece da quanto ho capito si deve fare p[n].a ....ho capito bene?

senza che ci stiamo a dilungare troppo... prova a compilare quel coso e fallo andare: è la migliore prova del funzionamento o del non funzionamento di un programma
bastano solo pochi secondi: il gcc è gratis. se non ti compila o non ti funziona torna qui e vediamo di che si tratta.
non fare come i miei colleghi universitari del primo anno, che quando c'era da consegnare il programma di laboratorio non solo non lo provavano ma neanche lo compilavano: incrociavano le dita...

[gepeppe]

si ora funziona grazie

[gepeppe]

edit