Newsgroup: it.comp.lang.c++
Titolo: vector<>::clear()

se ho un vettore di *miaclasse (std::vector<miaclasse*> miovettore) e
l'ho riempito con qualcosa come
miaclasse* oggetto = new miaclasse();
miovettore.push_back(oggetto);
prima di fare un clear su quel vettore
miovettore.clear();
devo rilasciare tutti gli oggetti?
for (unsigned int i = 0; i < miovettore.size(); i++) delete
miovettore[i];
oppure no?
-- 
]\/[ad]\/[age (
www.mindreamz.net
)
"Un Maestro insegue semplicemente la sua visione di Eccellenza in
qualunque cosa sta facendo e lascia agli altri decidere se sta 
lavorando o giocando. A lui sembra sempre di fare entrambe." - Anonimo

 devo rilasciare tutti gli oggetti?
Se devi distruggerli, sě.
std::vector<> (come gli altri container) non si mette certo a invocare
'delete' sui puntatori. (Perché dovrebbe, poi?)
Max

'delete' sui puntatori. (Perché dovrebbe, poi?)
in effetti...
ascolta, un altro dubbio: con un vettore del genere, se per iterare al
suo interno volessi usare un iteratore, devo fare per forza:
for (vector<miaclasse*>::iterator i = miovettore.begin(); i !=
miovettore.end(); ++i) {
	(*i)->membro_della_classe = 0xff;
}
??? insomma, non si può evitare in qualche modo quel fastidioso
(*i)->membro_della_classe ?!?!? chiaramente non si può fare
i->membro_della_classe, ma una sintassi un po' più carina?


 i->membro_della_classe, ma una sintassi un po' piů carina?
Certo. Puoi scrivere
   (*(*i)).membro_della_classe
E' piů carina? :)
Max


Un metodo che a me piace in questi casi, quando hai elementi nel vettore che
necessitano di operazioni extra (come ad esempio la gestione della memoria
nel caso siano puntatori o oggetti da distruggere o da salvare), è quello di
dervare da std::vector una tua classe che si ocupa di tutto, ne risulta che
il codice che produci è più leggibile e a mio avviso più robusto, comunque è
una mia opinione personale.
Ti scrivo un frammento di codice che non c'entra molto con i puntatori ma
che sto scrivendo adesso per un mio programma, lo puoi adattare ai tuoi
scopi...
class operatorList : public vector<Operator> {
        public:
        operatorList() : vector<Operator>(O,O+conta())  { }
        private:
        static ListaOperatori O;
        static unsigned int Noperatori;
        static int conta() {
                // conta il numero di operatori
                while (O[Noperatori].gerarchia!=0) ++Noperatori;
                return Noperatori;
        }
};
operatorList è una classe derivata da vector, viene costruita contando degli
elementi in un array e li trasferisce in un vettore (i motivi per cui faccio
questo non sono evidenti in questo esempio ma nel contesto di tutto il
programma hanno senso...serve la flessibilità di un vettore!).
Il dsitruttore per ora non c'è, questo comunque potrebbe farsi carico della
distruzione degli elementi.
Altra possibilità, nel caso si voglia invocare clear e non il distruttore è
quella di aggiungere il metodo clear alla classe, distruggere gli elementi
contenuti nel vettore e poi invocare vector<Operator>::clear(); ad esempio.
Ma torno a dire, non c'è nulla di sbagliato in quello che hai detto/scritto,
è solo un'idea... che a me piace molto, ma va a gusti!
In questo modo nel tuo codice scrivi semplicemente miovettore.clear() e la
tua classe si occupa di tutto, secondo me così risolvi il problema alla
radice e non corri il rischio di dimenticarti (all'interno di un listato
enorme) di distruggere gli oggetti creati col new...

 una mia opinione personale.
Non sarebbe meglio wrappare il vector in un'altra classe (pattern
decorator?) senza utilizzare l'ereditarietà?
I gusti sono gusti ma visto che std::vector non dichiara un distruttore o
altri metodi virtuali, pertanto il tipo di specializzazione che adotti può
essere meglio esplicitata mediante un contenimento.
IMHO.
-- 
Domenico Testa - Studente

 };
poi qualcuno scrive:
operatorList * olp = new operatorList;
// fa qualcosa con olp
delete olp;
e scoppia la terza guerra mondiale...
Non mi pare una buona idea. Meglio la delega, come qualcun'altro ti ha
suggerito.
Ciao,
Nicola
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 e scoppia la terza guerra mondiale...
Forse volevi scrivere:
 vector<Operator> * olp = new operatorList;
Max

 suggerito.
A questo punto me ne sono convinto!!
Ciao!

  vector<Operator> * olp = new operatorList;
Hai ragione.
