Quando una funzione restituisce, la memoria allocata tramite malloc viene liberata? O si può ancora accedere alla funzione main() usando i puntatori?Scopo di malloc utilizzato in una funzione
es.
void function(int *a)
{
a=(int *)malloc(sizeof(int));
*a=10;
}
int main()
{
int *num;
function(num);
printf("%d",*num);
return(0);
}
È possibile accedere all'intero memorizzato in a da main() qui?
No, la memoria allocata con malloc non viene liberato quando si esce dall'ambito/ritorno dalla funzione.
Sei responsabile di liberare la memoria di Malloc.
Nel tuo caso però, la memoria NON è accessibile in main(), ma è perché si tratta solo di una variabile locale.
void function(int *a)
{
a=(int *)malloc(sizeof(int));
Qui, a è una variabile locale all'interno function. I puntatori vengono passati per valore in C, quindi a riceve una copia del puntatore principale quando si esegue function(num); main() non si vede che si assegna a quella copia locale del puntatore.
quello che dovete fare uno:
void function(int **a)
{
*a= malloc(sizeof(int));
**a=10;
}
int main()
{
int *num;
function(&num);
printf("%d",*num);
free(num);
return(0);
}
o
int* function(void)
{
int *a= malloc(sizeof(int));
*a=10;
return a;
}
int main()
{
int *num;
num = function();
printf("%d",*num);
free(num);
return(0);
}
malloc() La memoria viene liberata solo quando si chiama free() su di esso. È accessibile a chiunque abbia un puntatore valido fino a quel momento.
La memoria non viene liberata. Qualsiasi funzione può allocare memoria e qualsiasi altra può deallocarla. È un vero casino se non sei super-schizzinoso, fino a quando ... qualcuno ha inventato la Garbage Collection.
No. Si passa il puntatore num in base al valore, quindi le modifiche apportate da function non si rifletteranno in main. Così effettivamente non v'è alcun modo per accedere/libera la memoria allocata da main
Per risolvere questo problema è possibile passare l'indirizzo di num o ritornare a da funzioni e raccogliere il valore restituito in num
malloc sta lavorando bene (anche se si dovrà chiamare free() sul puntatore restituisce). Il problema qui è che non si sta restituendo un puntatore alla memoria allocata.
"int * a", il parametro su function() è l'indirizzo di un numero intero. Il solito modo per tornare che sarebbe quello di riscrivere la funzione come segue:
int * function()
{
int * a = (int *)malloc(sizeof(int));
*a = 10;
return a;
}
di restituirla attraverso un parametro, si deve restituire l'indirizzo del puntatore:
// pp points to a pointer
void function(int ** pp)
{
// Assign allocated memory to the thing that pp points to
*pp = (int *)malloc(sizeof(int));
// Get the thing pp points to -- a pointer.
// Then get the thing which THAT pointer points to -- an integer
// Assign 10 to that integer.
**pp = 10;
}
void main()
{
int * p = NULL;
function(& p);
printf("%d\n", *p);
free(p);
}
E ora sapete perché hanno inventato il C#.
Ecco un modo per riscrivere la vostra cosa allocazione in modo che sia più chiaro:
void function(int ** pp)
{
int * newmemory = (int *)malloc(sizeof(int));
// Assign 10 to the integer-sized piece of memory we just allocated.
*newmemory = 10;
// Assign allocated memory to the thing that pp points to.
*pp = newmemory;
}
È possibile memorizzare l'indirizzo diretto della memoria allocata in un contenitore lista quindi creare una funzione per ciclo, accedere ad ogni indirizzo in un funzione libera, quindi fai uscire l'indirizzo. È possibile inserire l'indirizzo direttamente nella funzione gratuita come free(myaddresslist.front()); myaddresslist.pop_front();. Questo è un modo quasi di fare la tua raccolta dei rifiuti senza dover modificare l'intero progetto in linguaggi basati su GC. Utilizzare myaddresslist.size() per assicurarsi di non chiamare free() su un campo vuoto (risultante in un arresto anomalo) e per determinare il numero di cicli da eseguire.