Newsgroup: it.comp.os.linux.development
Titolo: Malloc da dentro a funzione....come ?

Cio' che vorrei fare io e' una cosa di codesto genere:
void init(int* i)
{
    i=(int*)malloc(sizeof(int));  // [*2]
    *i=10;
}
int main(void)
{
    int* MyInt;
   // MyInt=(int*)malloc(sizeof(int)); // [*1]
    init(MyInt);
    printf("%d\n",*MyInt);
}
Nella riga (commentata) con [*1] c'e' la situazione normale per la 
malloc e se decommento quella parte e commento la riga con [*2] il tutto 
funziona correttamente, come giusto che sia.
Se invece tengo la cosa cosi' nella variabile MyInt ottengo un valore 
immondo (nel senso che non ha un valore minimamente vicino a 10).
Nota:
void init(int* i) -> e' cosi' e non posso metterla come (int** i), che 
altrimenti mi avrebbe gia' risolto la questione
Grazie anticipatamente.
Ciao
     MaX



Non puoi neanche trasformarla in:
int* init(int* i)
e terminarla con:
return i;
?
-- 
Mario "Reliant" Pascucci
Linux user #327002 - 
http://counter.li.org/
http://ilpettegolo.altervista.org/

 ?
no :(



L'unica rimasta che mi viene in mente (ma ho i brividi...) e' una
variabile globale (ORRORE) messa cosi':
int* mammamia;
void init(int* i)
{
    i=(int*)malloc(sizeof(int));  // [*2]
    *i=10;
    mammamia=i;
}
int main(void)
{
    int* MyInt;
   // MyInt=(int*)malloc(sizeof(int)); // [*1]
    init(MyInt);
    MyInt = mammamia;
    printf("%d\n",*MyInt);
}
ma a parte i brividi e gli scherzi, non hai alcun modo per capire se il
malloc interno a init sia andato a buon fine, e se il puntatore in
"mammamia" sia valido, a meno di metterlo a NULL tutte le volte dopo che
lo hai usato.
Toglimi una curiosita'... e' un esercizio "scolastico"? ;-)


 Toglimi una curiosita'... e' un esercizio "scolastico"? ;-)
Usare una variabile globale non e' proprio la cosa piu' adatta.
Si e' un esercizio "scolastico" e' un punto di un progetto sul quale mi 
son fermato perche' mi sono io intestardito a volerlo fare cosi', ma 
potrei anche adottare un'altro approccio.
Ho una serie di funzioni dichiarate in un file header, e so lo scopo di 
ogni funzione, nulla piu', e anche lo scopo non e' proprio fissato 
rigidamente, unica cosa fissa son le dichiarazioni delle funzioni.
Il discorso e' che son testardo io che voglio riuscire a fare quella 
cosa che ho in mente !
Ciao
	MaX

YattaMaX wrote:

Tu vorresti chiamare una funzione che ti allochi della memoria dove 
vuole lei e poi vorresti usare tale memoria. Quindi tale funzione ti 
deve rendere l'indirizzo di tale memoria allocata. Per renderla puo' 
usare uno scope esterno (globale), il valore di ritorno o un parametro.
Se non vuoi usare uno scope esterno ne' modificare il prototipo della 
funzione, mi sembra che l'unica possibilita' e' sfruttare l'area puntata 
dal parametro, che e' dichiarata essere un intero, per passargli un 
puntatore sotto mentite spoglie. E' lecito in quanto i puntatori, di 
regola, hanno tutti la stessa lunghezza.
Ecco il codice:
void init(int* i)
{
    *(int **)i=(int*)malloc(sizeof(int));
    **(int **)i=10;
}
int main(void)
{
    int* MyInt;
    init((int *)&MyInt);
    printf("%d\n",*MyInt);
    free(MyInt);
}
P.S. Ho aggiunto la chiamata a free per disallocare la memoria.
-- 
     Carlo Milanesi
 
http://digilander.libero.it/carlmila

 altrimenti mi avrebbe gia' risolto la questione
è un errore concettuale. La soluzione giusta è passare un int **i,
perché passi la copia dell'indirizzo del puntatore. Se non fai così
qualsiasi altra soluzione è sbagliata o comunque molto poco elegante.

 regola, hanno tutti la stessa lunghezza.
A norma di standard non e` lecito. Diciamo che funziona su x86, su altre
architetture il cast tra puntatori a tipi diversi e` piu` problematico.
Luca
-- 
Home: 
http://kronoz.cjb.net
"Fare l'amore con dieci donne e` fantastico, soprattutto perche` ti
 presentano un sacco di amiche." -- Fabio Di Iorio