Originariamente inviato da weo
Salve a tutti.
Non sono riuscito a trovare molto su internet, e la maggior parte dei documenti è in inglese, dove arranco parecchio.
Se avete qualche sito in particolare che mi può illuminare vi ringrazio.
(le domande si riferscono al c, con un compilatore gcc e sistema linux)
1-memoria dinamica: Quando creo "qualcosa" dinamicamente (array struct ecc...), questo alla terminazione del processo che lo ha creato viene liberato automaticamente dalla memoria?
Sì.
E se è all'interno di una funzione, all'uscita della funzione viene mantenuto in memoria?
Certo.
2-liberare memoria: Quando è necessario? (questo non l'ho ben capito, se mi fate due esempi vi rignrazio)
Quando non ti serve più della memoria che hai allocato dinamicamente. Un paio di esempi:
codice:
char * stringa = malloc(500); /* alloco nell'heap una stringa di 500 caratteri */
/* uso la stringa */
/* ... */
/* ho finito di usarla e non mi serve più */
free(stringa); /* la dealloco */
stringa = NULL /* questo non è strettamente necessario, ma in questo modo sono sicuro di non utilizzare più il puntatore alla memoria che avevo allocato, che ora punta a memoria non allocata */
codice:
char stringa[500]; /* alloco sullo stack una stringa di 500 caratteri */
/* uso la stringa */
/* ... */
/* ho finito di usarla e non mi serve più, ma, visto che è allocata sullo stack, non c'è bisogno di deallocarla, verrà deallocata automaticamente all'uscita dalla funzione */
3-come liberare memoria:
Es:
ho un array:
int * array_di_int;
va bene se lo libero cosi?:
for(i=0;i<lunghezza_array;i++)
free(array_di_int[i]);
No; devi fare così:
codice:
int * array_di_int;
array_di_int = malloc(50 * sizeof(int)); /* alloco l'array in modo che contenga 50 interi */
/* uso l'array */
/* ... */
/* lo dealloco */
free(array_di_int);
.
In generale ricorda che ad ogni malloc corrisponde una free, non di più.
mentre come procedo se ho un:
int ** array_di_int;
Be', dipende da come lo allochi e come lo utilizzi...
4-proprietà processi creati con fork:
Allora, quando creo dei processi con la fork, da quel che ho capito, si viene a creare un processo padre e uno figlio.
Il figlio è la "copia" del padre, cioè ha lo stesso codice e la stessa "memoria" che ha il padre fino a quel momento. Condividono anche la tabella dei file aperti.
Quindi sono praticamente lo stesso programma che si sdoppia? (correggete pure gli eventuali errori nella definizione sopra)
Più o meno... tranne che la fork restituisce 0 al processo figlio e il PID del figlio al processo padre.
Occhio però che, se non ricordo male, i due processi non condividono la stessa tabella dei file aperti, ognuno ne ha una differente con copie dei descrittori ai file (ma su questo non ci giurerei, aspetta risposte più autorevoli).