Newsgroup: it.comp.programmare.win32
Titolo: CObArray liberare memoria

Ho una struttura ad albero che contiene oggetti CObArray come la seguente.
 
struct CElement : public CObject {
	CString Gruppo;
	CObArray *Items;
	CObArray *Childs;
	CElement *Father;
	CElement();
	~CElement(void);
};
 
Per cancellare elementi dell'array uso la funzione RemoveAt() della classe
CObArray, il mio problema č nel fatto che questa operazione elimina l'elemento
dall'array ma non libera memoria.
 
Se si trattasse di un singolo Array di oggetti il problema verrebbe risolto
effettuando, successivamente al RemoveAt() un delete(object). Il problema č
che nel mio caso si tratta di una struttura ad albero che ha oggetti CObArray
annidati dunque al momento della cancellazione di un nodo della mia struttura,
devo cancellare tutti i sui figli e fratelli.
 
La cosa mi sembra piuttosto complicata. Ad ogni modo potrei scorrere tutto
l'albero con una funzione ricorsiva ed effettuare i delete() di ogni oggetto
contenuto negli ObArray se non fosse per il fatto che in questo modo andrei a
cancellare i riferimenti durante la ricorsione e non credo la cosa funzioni.
Mi sbaglio?
 
Qualche idea a riguardo per risolvere il problema?
 
-- 
Caronte
-- 
Inviato da 
Newsgate.Localinfo.IT
 Web Service
http://newsgate.localinfo.it

 devo cancellare tutti i sui figli e fratelli.
Perchè non segui le pratiche del C++ e quindi sbagli. Hai un distruttore:
nel distruttore devi distruggere tutte le cose allocate sull'heap (in questo
caso i due CObArray e il CElement).
Mi spieghi perchè hai dei puntatori invece che direttamente degli CObArray?
Se ti senti pigro (molti si sentono pigri) prova
CAutoPtr<CObArray> Items.
Per allocarlo:
Items.Attach(new CObArray)
e poi usi normalmente Items->...
Quando il CElement viene distrutto CAutoPtr provvede a liberare la memoria.
--- bye

 Quando il CElement viene distrutto CAutoPtr provvede a liberare la memoria.
 
Grazie della dritta. Proverò entrambe el soluzioni.
 
Ciao


 caso i due CObArray e il CElement).
 
Ti piace questo distruttore?
 
CElement::~CElement() {
	register int i;
 
	if (this->Childs) {
		for (i=0; i < this->Childs->GetCount(); i++) {
			delete(this->Childs->GetAt(i));
		}
		delete(this->Childs);
	}
 
	if (this->Items) {
		for (i=0; i < this->Items->GetCount(); i++) {
			delete(this->Items->GetAt(i));
		}
		delete(this->Items);
	}
}
 
Sembra funzionare correttamente, ovviamente del CElement non devo cancellare
l'oggetto perchè si tratta del nodo padre.
 
Ciao


 Childs. Se fossero CObArray dovrei controllare il numero di elementi.
E quindi? Che differenza c'è? Non usi un puntatore per una stro##ata del
genere! Cmq se almeno il 50/60% delle volte non ci sono child e items allora
va benissimo (un array anche vuoto occupa parecchio)
--- bye

> register int i;
E' esagerato considerando quello che fai. basta int i;
--- bye

 va benissimo (un array anche vuoto occupa parecchio)
 
Che fai parli e poi ti penti ;)
Tu che dici? In una struttura ad albero ogni nodo deve avere la possibilità di
avere figli quindi ce ne saranno molti non inizializzati per forza di cose!!
In effetti è anche un discorso di memoria oltre che di ottimizzazione.
 
Ad ogni modo, almeno io, sono abituato a creare funzioni che possano elaborare
moltissimi dati nel modo più veloce possibile, anche se poi le uso per pochi
elementi. In questo caso l'uso del puntatore invece che l'oggetto mi
sembra fondamentale.
 
Pensa quanto sarebbe pesante la funzione ricorsiva di ricerca di un nodo se
dovesse ogni volta controllare il numero degli elementi dell'array per sapere
se è vuoto o inizializzato.
 
Comunque grazie dei consigli, ho risolto alla grande.
