[C] Allocazione Dinamica

[Doriän]

Salve! Torno di nuovo per un piccolo programmino che sto utilizzando a scopo didattico (e sul quale avevo già chiesto informazioni sul questa board, qui). Mi sono, prevedibilmente, impantanato sull'allocazione dinamica. Dunque, il codice che mi crea problemi è il seguente:

variabili, penso sia utile metterle...

	int lamp[MAX_LAMP], i, j=0, swap, flag=0, L=0, P=0, PulsCountr=1, IND_PUL=0,
			IND_LUC=0;
	char riga[100], comando[10], c;
	typedef struct main_struct {
		char *PUL;
		int *LUCI;
	} PULS;
	PULS *PULSANTI;
	FILE *fp;

...e resto di codice

        /*Allocazione dinamica*/
	PULSANTI = malloc(sizeof(PULS)); //allocazione dinamica di PULSANTI

	if (PULSANTI==NULL) { //controllo errori su allocazione PULSANTI
		printf("1- Errore durante l'allocazione dinamica della memoria.\n");
		printf("Premere un tasto...");
		getch();
		return (EXIT_FAILURE);
	} else {
		PULSANTI->PUL = malloc(sizeof(char));
		PULSANTI->LUCI = malloc(sizeof(int));
	}
	if (PULSANTI->PUL==NULL|| PULSANTI->LUCI==NULL) { //controllo errori su allocazione campi di PULSANTI
		printf("1b- Errore durante l'allocazione dinamica della memoria.\n");
		printf("Premere un tasto...");
		getch();
		return (EXIT_FAILURE);
	}

	//In questo while vengono letti e copiati i comandi
	while (fgets(riga, sizeof(riga), fp) != NULL) {
		if (isalpha(riga[0])) {
			for (i=0; i<10; i++) {
				if (isalpha(riga[i])) {
					c = riga[i];
					PULSANTI[j].PUL[IND_PUL] = c;
					IND_PUL++;
					printf("1\n");
				} else if (isdigit(riga[i])) {
					printf("2\n");
					PULSANTI[j].LUCI[IND_LUC] = riga[i]-48; //todo: sistemare questa cagata
					IND_LUC++;
				}
			}
			j++;
			IND_LUC = IND_PUL = 0;
			PulsCountr++;

			/*reallocazione dinamica*/
			PULSANTI = realloc(PULSANTI, PulsCountr*sizeof(PULS));
			if (PULSANTI==NULL) { //controllo errori su allocazione PULSANTI
				printf("2- Errore durante l'allocazione dinamica della memoria.\n");
				printf("Premere un tasto...");
				getch();
				return (EXIT_FAILURE);
			} else {
				PULSANTI->PUL = malloc(sizeof(char));
				PULSANTI->LUCI = malloc(sizeof(int));
			}
			if (PULSANTI->PUL==NULL|| PULSANTI->LUCI==NULL) {
				printf("2b- Errore durante l'allocazione dinamica della memoria.\n");
				printf("Premere un tasto...");
				getch();
				return (EXIT_FAILURE);
			}
			printf("3\n");
		}
	}

(p.s., parte delle printf sono a scopo di debug volante, anche se uso Insight)

La prima acquisizione la fa alla grande (eh, magari per vedere cosa fa il programma potreste dare un'occhiata all'altro thread, altrimenti diventa troppo pesante - già così è un mattone!), ma appena cerca di accedere PULSANTI[j].PUL[IND_PUL] dopo la reallocazione segfaulta, il che mi fa pensare che vada ad accedere ad una porzione di memoria che non posso toccare. Quindi immagino di fare qualche errore nella reallocazione. Ho provato utilizzando la realloc, ma niente. Non mi da errori in fase di allocazione, quindi già è un qualcosa. Forse è un errore di dereferenziazzione? Non credo, ma....
grazie già di avermi prestato attenzione!

[andbin]

Originariamente inviato da Doriän

		PULSANTI->PUL = malloc(sizeof(char));
		PULSANTI->LUCI = malloc(sizeof(int));

Così allochi solamente 1 char e 1 int. In pratica hai solo 1 elemento nel tuo array, puoi solo fare PULSANTI->PUL[0] e PULSANTI->LUCI[0], nulla di più.

Idem per la allocazione della struttura, visto che poi ci accedi con PULSANTI[j].

Se vuoi più elementi specificalo alla malloc.

[Doriän]

Segfaulta anche con

PULSANTI->PUL = realloc(PULSANTI->PUL, P*sizeof(char));
PULSANTI->LUCI = realloc(PULSANTI->LUCI, L*sizeof(int));

e

PULSANTI->PUL = malloc(P*sizeof(char));		
PULSANTI->LUCI = malloc(L*sizeof(int));

, dove P e L sono rispettivamente il numero esatto di pulsanti e luci che mi servono (provato anche P+1 e L+1, visto che è un vettore etc etc, 0 elemento iniziale etc etc).
O l'errore è proprio in questo modo di allocare?

edit: dubito che sia l'allocazione della struttura in se il problema. ho cercato di andare passo passo, e nel processo di sviluppo, diciamo così, ho prima allocato dinamicamente la struttura lasciando però i campi allocati staticamente, e non dava nessun problema. i problemi sorgono proprio quando cerco di allocarmi il numero esatto di "pulsanti" e "luci" (i campi della struct, quindi) che mi servono...

[Doriän]

Bumpete. Proprio nessun'idea?

[andbin]

Originariamente inviato da Doriän

dove P e L sono rispettivamente il numero esatto di pulsanti e luci che mi servono

Ok, quanto valgono questi P e L?

Inoltre ti faccio notare che è molto pericoloso fare:

PULSANTI = realloc(PULSANTI, PulsCountr*sizeof(PULS));
if (PULSANTI==NULL) {
.....

Se la realloc non riesce a riallocare il blocco (per qualunque motivo), ritorna NULL ma il blocco di memoria puntato originalmente da PULSANTI non viene in alcun modo toccato, è ancora lì dove è! Assegnando il valore subito a PULSANTI, tu in pratica ti "perdi" il puntamento al blocco originale che esiste ancora. In gergo tecnico si chiama "memory-leak".

[Doriän]

Allora, nel file che utilizzo per provare L vale 3 e P vale 3:

3
3
ABC 1 2
CBA 2 3
BCA 1 3

L totale luci, P totale pulsanti. L'obiettivo è far si che qualsiasi valore di l e p vada bene (ovviamente utilizzando un .txt formattato ad hoc, non posso sbattermi anche per controllare eventuali errori li dentro , tanto più che non dovrebbe nemmeno rientrare nei miei ipotetici compiti qualora tutto ciò fosse qualcosa di più serio); utilizzando un programma costruito apposta su un valore noto di L e P il tutto gira alla perfezione, questo dovrebbe essere l'ultimo passo, in teoria.

Per quanto riguarda il secondo appunto...potrebbe essere proprio quello il problema? Perdendo la possibilità di "puntare" al blocco di memoria di PULSANTI non potrei più riaccedervi...però non serve più accedervi no? Voglio dire, dovrebbe segfaultare più giù nel codice, quando vado a cercarmi proprio quella parte la...


ahem, allego il sorgente intero? Perché magari è più chiaro...
intanto legog qualcosa in più sul memory leak...grazie per la dritta andre'!

[Doriän]

Ultimo up, prometto!
Che poi è per una cosa positiva, in quanto ho finalmente risolto il problema e posto il metodo che ho utilizzato, qualora dovesse tornare utile a qualcuno!

Il codice funzionante è il seguente:

/*Allocazione dinamica*/
	PULSANTI = calloc(P, sizeof(PULS)); //allocazione dinamica di PULSANTI

	if (PULSANTI==NULL) { //controllo errori su allocazione PULSANTI
			printf("1- Errore durante l'allocazione dinamica della memoria.\n");
			printf("Premere un tasto...");
			getch();
			return (EXIT_FAILURE);
		} else {
			PULSANTI->PUL = calloc(P, sizeof(char));
			PULSANTI->LUCI = calloc(L, sizeof(int));
		}
		if (PULSANTI->PUL==NULL|| PULSANTI->LUCI==NULL) { //controllo errori su allocazione campi di PULSANTI
			printf("1b- Errore durante l'allocazione dinamica della memoria.\n");
			printf("Premere un tasto...");
			getch();
			return (EXIT_FAILURE);
		}

	//In questo while vengono letti e copiati i comandi
	while (fgets(riga, sizeof(riga), fp) != NULL) {
		if (isalpha(riga[0])) {
			for (i=0; i<20; i++) {
				if (isalpha(riga[i])) {
					c = riga[i];
					PULSANTI[j].PUL[IND_PUL] = c;
					IND_PUL++;
					} else if (isdigit(riga[i])) {
					PULSANTI[j].LUCI[IND_LUC] = riga[i]-48; //TO DO: sistemare questa cagata
					IND_LUC++;
					}
			}
			j++;
			IND_LUC = IND_PUL = 0;
			AllocCountr++;
	
			/*reallocazione dinamica*/
			(PULSANTI[AllocCountr]).PUL = calloc(P, sizeof(char));
			(PULSANTI[AllocCountr]).LUCI = calloc(L, sizeof(int));

			if ((PULSANTI[AllocCountr]).PUL==NULL|| (PULSANTI[AllocCountr]).LUCI==NULL) {
				printf("2b- Errore durante l'allocazione dinamica della memoria.\n");
				printf("Premere un tasto...");
				getch();
				return (EXIT_FAILURE);
			}
		}
	}

Pensando un po' su quello che mi ha suggerito Andrea ho capito che dovevo allocare non i campi della struct PULSANTI riallocata, bensì i campi di PULSANTI[index]. Ho allocato il tanto giusto per PULSANTI alla prima allocazione e in quella che viene dopo l'acquisizione dei caratteri andavo a riallocare utilizzando un indice, AllocCountr, che veniva incrementato mano a mano che ciclavo. Ho anche sostituito tutte le malloc con calloc ma penso sia un cambiamento di relativa importanza. ora il programma funziona per qualsiasi .txt vada a leggere (opportunamente formattato), ed è esattamente quello che volevo. Be', più o meno. Il "problema" ora è questo for,

for (i=0; i<20; i++) {
...
}

Quel 20 indica il numero di caratteri che l'fgets legge; se provo a metterci un sizeof(riga), come dovrebbe essere, si arrabbia. Poco male, tutto sommato, ma ora che il problema grosso è risolto posso pensare a queste limature!
Grazie ancora ad andrea per le dritte!