Oppure

Loading
24/03/10 10:43
robrock80
Innanzi a tutto volevo chiedervi se è corretta la seguente riga per allocare dinamnicamente array di i + 1 stringhe 

char** strArr = (char**)malloc(sizeof(char*) * (i + 1));


Seccome volevo utilizzare l'ultimo elemento dell'array come indicatore di fine array mi chiedevo: la malloc inizializza i punatori successivi al primo a zero, ossia strArr + 1, strArr + 2, etc... sono = a 0?
Ultima modifica effettuata da robrock80 24/03/10 10:45
aaa
24/03/10 11:58
TheKaneB
in questo modo allochi lo spazio per i puntatori alle stringhe. Ti occorre una nuova malloc per ogni puntatore per allocare lo spazio delle stringhe vere e proprie.

Ad ogni modo malloc non inizializza nulla... usa calloc per allocare e settare un intero array a zero: cplusplus.com/reference/clibrary/cstdlib/calloc/

ciao ;)
aaa
24/03/10 12:03
robrock80
Ok, ti ringrazio... Per deallocarlo ho scritto invece il seguente codice 

void freeCharMatrix(char** toFree) {
	int i = 0;
	for (; *(toFree + i) != 0; i++) {
		//printf("%d\n", i );
		free(*(toFree + i));
	}
	free(*(toFree + (i + 1)));
	free(toFree);
}


Va bene?
aaa
24/03/10 12:12
TheKaneB
Postato originariamente da robrock80:

Ok, ti ringrazio... Per deallocarlo ho scritto invece il seguente codice 

void freeCharMatrix(char** toFree) {
	int i = 0;
	for (; *(toFree + i) != 0; i++) {
		//printf("%d\n", i );
		free(*(toFree + i));
	}
	free(*(toFree + (i + 1)));
	free(toFree);
}


Va bene?


va quasi bene (leggi il "PS" nel codice) se hai fatto una malloc/calloc per ogni stringa, ma io lo aggiusterei un po' così: 

void freeCharMatrix_versionepulita_(char** toFree)
{
  if ( toFree ) // Evitiamo di dereferenziare possibili puntatori nulli
  {
    char *pCurrent = *toFree; // prendo il primo puntatore dell'array

    while ( pCurrent!= 0 ) // non creiamo espressioni condizionali illegibili, please!
    {
      free( pCurrent );
      pCurrent++; // usiamo l'aritmetica dei puntatori per andare al successivo
    }
    // PS: l' (i+1)-esimo puntatore è NULL per definizione, quindi non posso deallocarlo!

    free( toFree );    
  }
}


Dimmi se ti garba la correzione ;)
aaa
24/03/10 12:27
robrock80
Si, mi piace, si legge meglio. Però ho un dubbio sul PS: se io alloco "i + 1" anche se l'ultimo elemento lo lascio a 0, io devo comunque deallocarlo, altrimenti la CPU non libera quella parte di memoria, fino a che il processo non è chiuso, mi sbaglio?
aaa
24/03/10 12:31
TheKaneB
ti sbagli...

con una malloc/calloc, allochi l'array di puntatori a char di dimensione N+1.

Poi, dentro un ciclo for, allochi altri N array di char (le stringhe), mentre l'N+1-esimo elemento lo setti a 0 (quindi rimane allocato l'elemento, ma non punta a nessuna stringa).

quando deallochi, prima elimini le N stringhe, poi elimini l'array di N+1 puntatori. L'elemento N+1 non è mai stato occupato da un buffer allocato, quindi non devi deallocarlo per nessun motivo. Diciamo che facendo il free dell'array di N+1 elementi, se ne va anche la memoria occupata da quel puntatore nullo nella posizione N+1 (così come se ne vanno anche tutti i precedenti N puntatori).
aaa
24/03/10 12:34
robrock80
ahhhhh... Ok, ok, ora capito... Grazie di nuovo:k:
aaa
24/03/10 12:35
TheKaneB
figurati ;)
comprendere appieno il meccanismo di gestione manuale della memoria in C non è facile :)
aaa