Newsgroup: it.comp.lang.c++
Titolo: Allocazione di memoria

Salve a tutti,
sono nuovo ma ho lurkato i vostri ultimi 1200 msg quindi penso di essermi
guadagnato il diritto ad una domanda :-)
Utilizzando il free usando una config. di DEBUG in compilazione sono in
grado di capire se l'area di memoria e' stata effettivamente deallocata. In
Release non ci riesco per due motivi :
1 - perche' non mi vengono compilate le istruzioni valide solo in debud (e
mi sembra ovvio)
2 - perche' non riesco a scandagliare la memoria con il valore che soleva
mettermi come default.
Visto che il mio programma alla fine verra' compilato in release vi chiedevo
se qualcuno conosce qualche funzione che mi dica se la variabile ad esempio
char* per non dire int* e' gia' stata allocata utilizzando free oppure no
(anche se potrei utilizzare una malloc a 0 anche nel caso sia gia' libera e
poi deallocarla ma e' l'ultima cosa che vorrei fare per stile di
programmazione).
Scusatemi per la lunghezza e grazie a chi almeno legge il mex.
--
Salvatore Ragusa - Virgo
UIN 51093884
EMail 
vi...@libero.it

 char* per non dire int* e' gia' stata allocata utilizzando free oppure no
"Allocata utilizzando free"?  Immagino tu intenda "allocata
utilizzando malloc".
Purtroppo, il C++ non ha una funzionalita` del genere come
parte dello standard.  Se l'allocazione usasse le modalita`
normali C++ (cioe` operator new) potresti taroccare qualche
cosa tu abbastanza facilmente, poiche` lo standard C++
prevede che tu possa sostituire operator new con una tua
implementazione; ma se invece per qualche misteriosa
ragione devi usare, pur essendo in C++, le modalita` tipiche
del C, non vi e` alcun approccio standard per ottenere
l'esatta funzionalita` da te richiesta.
Non e` chiaro, tuttavia, che questa funzionalita` ti sia
davvero indispensabile.
Perche` non inizializzi i tuoi puntatori a zero alla loro
definizione, riazzerandoli poi ogni volta che liberi la
memoria cui puntano?  In questo modo, potresti
agevolmente effettuare il tuo test.
Alex

> char* per non dire int* e' gia' stata allocata utilizzando free oppure no
De-allocata? Io di solito metto a NULL il puntatore nella riga successiva al
free, cosě poi basta un
if (puntatore)
    // Allocata
else
    // Non allocata
E lo stesso faccio al momento della creazione, se non la inizializzo
all'istante in altro modo.
Alcuni preferiscono usare il valore 0 (zero).
--
Alessandro Monti

 agevolmente effettuare il tuo test.
Ti ho risposto sopra e ti ringrazio per l'interessamento.


 Alcuni preferiscono usare il valore 0 (zero).
Il valore e` necessariamente lo stesso (cosi` sancisce lo
standard)...:-).
Alex

 > definizione, riazzerandoli poi ogni volta che liberi la
In particolare, potresti fare qualcosa del tipo:
    inline template<class T>
    void libera(T*& p) {
        free(p);
        p=0;
    }
Se ti ricordi di fare sempre libera(p) invece di
free(p), sei a posto:-).
Alex

Si? e i problemi legati a definizioni tipo
#define NULL (void *)0
Ciao,
Nicola

 #define NULL (void *)0
Questo violerebbe lo standard C++.
Infatti,
    int* p = NULL;
dovrebbe a norma di standard C++ fallire secondo
questa definizione che tu proponi.
L'*UNICA* definizione corretta in C++ e` dunque
#define    NULL    0
Forse ti confondi con altri linguaggi, diversi dal
C++, come, ad esempio, il linguaggio C, dove
in effetti il "#define" che proponi sarebbe invece
ammissibile.
Alex

 ammissibile.
Credo di aver chiarito sopra qual'era il mio dubbio.
Ciao.
Nicola

 no.
In effetti no (0L potrebbe essere un'alternativa a 0 non
decorato, e lo standard l'ammette esplicitamente) ma quel
che di certo e` inammissibile e` (void*)0.
Diciamo dunque piu` precisamente: 0 non decorato va sempre
bene (qualsiasi implementazione deve accettare una mia macro
#define MYNULL 0 dopo la quale io usi sempre MYNULL invece
di NULL) ma potrebbe andare bene anche un'altra definizione
(0L) purche` naturalmente sia una "null pointer constant", che
a sua volta (4.10 sub 1) e` una *INTEGRAL constant
expression ...  of INTEGER type ... che valuta a 0" (mie enfasi).
Quindi, "(void*)0" e` SICURAMENTE sbagliato.  E non vi e`
nessuna ragione pratica sensata per qualsivoglia implementazione
di usare 0L invece che 0, benche` sia ammesso.
Alex