Newsgroup: it.comp.lang.c
Titolo: Domanda su free

Salve!
Avrei una domanda da porvi...
int *populate(unsigned int dim)
{
        unsigned int i = 0;
        int *values;
        values = calloc(dim, sizeof(int));
        for(i = 0; i < dim; i++) values[i]=((rand()>>23) - (rand()>>24));
        return values;
        free(values);
}
è corretta questa funzione?!? 
...cioè la free va bene dove l'ho messa? oppure la memoria allocata da
values in realtà non viene mai deallocata fin quando non viene killato il
programma?
Se ho sbagliato (sicuramente visto che sono andato a intuito) mi potreste
suggerire un modo + intelligente per fare la stessa cosa (e risolvere così
il mio dubbio)?
Grazie 
VinX

 il mio dubbio)?
Studiare meglio le regole del linguaggio mi sembra la cosa piu' 
intelligente...
Comunque, in questo codice, la free non viene mai chiamata perche' che 
sta dopo il return. Infatti l'esecuzione di una istruzione return causa 
l'uscita *immediata* dalla funzione, restituendo il valore specificato 
(in questo caso values). E poi, ammesso che il codice funzionasse non 
avrebbe senso: restituiresti un puntatore a un settore di memoria non 
allocata, dato che free l'avrebbe gia' liberata. La soluzione al tuo 
problema potrebbe essere eliminare la free dalla funzione e metterla 
nella chiamante esattamente nel punto in cui la memoria allocata smette 
di servirti.
-- 
Devaraja (Xdevaraja87^gmail^c0mX)
Linux Registerd User #338167
http://counter.li.org

 memoria allocata smette di servirti.
vediamo se ho capito... completando l'esempio di prima:
#include <stdio.h>
#include <stdlib.h>
typedef unsigned int _uint;
int *populate(unsigned int dim)
{
        unsigned int i = 0;
        int *values;
        values = calloc(dim, sizeof(int));
        for(i = 0; i < dim; i++) values[i]=((rand()>>23) - (rand()>>24));
        return values;
}
int main(int argc, char *argv[])
{
        unsigned int dim = 10;
        int *valori;
        valori = calloc(dim, sizeof(int));
        valori = populate(dim);
        free(valori);
        return EXIT_SUCCESS;
}
dovrebbe andar bene!! ;)

 
Si, a parte quella doppia allocazione va tutto bene. Ah.. ovviamente il 
puntatore valori va utilizzato prima di chiamare free :-)


 puntatore valori va utilizzato prima di chiamare free :-)
 
ottimo! Grazie ancora per l'aiuto!

Comunque sarebbe più opportuno a mio parere
allocare e liberare la memoria fuori dalla procedura
populate, e poi semplicemente passare alla procedura
populate il puntatore e la dimensione. Sarebbe anche
più utile, per esempio, nel caso tu dovessi ripopolare
l'array (evitando così di riallocare per niente) o popolarne
uno già creato (magari non da te...)
A. Fontana
www.e-nuts.net
 

Andrea Fontana wrote:

ok quindi se ho capito il tuo suggerimento dovrei fare così:
#include <stdio.h>
#include <stdlib.h>
int *populate(int *values, unsigned int dim)
{
        for(i = 0; i < dim; i++) values[i]=((rand()>>23) - (rand()>>24));
        return values;
}
int main(int argc, char *argv[])
{
        unsigned int dim = 10;
        int *valori;
        valori = calloc(dim, sizeof(int));
        valori = populate(valori, dim);
        //altre operazioni
        free(valori);
        return EXIT_SUCCESS;
}
giusto?

        valori = populate(valori, dim);
semplicemente diventa:
populate(valori,dim);


grazie 1000 ho capito un'altra cosa!! ;)