Newsgroup: it.comp.lang.c++
Titolo: std::list

Ciao.
Ho un dubbio sulle std::list.
Definita una classe Obj qualunque (diciamo tale per cui il costruttore
di copia sia dispendioso), voglio gestirne dei container.
La prima idea e' ovviamente un std::vector<Obj>, ma ha due grossi
difetti: inserire un elemento puo' provocare diverse copie di oggetti
Obj e anche l'estrazione richiede una copia e la distruzione
dell'oggetto nel container.
Quindo ho usato un std::vector<Obj*>, il che mi consente di lavorare con
prestazioni decenti perche' gli oggetti stessi non vengono mai mossi,
solo i loro puntatori. Questa soluzione mi piace pero' un po' poco, in
quanto devo mantenere il tutto coerente in modo manuale. Ovvero posso
combinare disastri come cancellare (con delete) un oggetto e lasciarne
il puntatore (ormai invalido) nel vettore. Ovvero ancora, dato
std::vector<Obj*>::iterator a; devo fare due operazioni {delete *a;
Vettore.erase(a);} e cosi' via.
Mi e' venuto da pensare che una soluzione piu' elegante potesse essere
l'uso di una std::list<Obj>, in quanto operazioni su questo container
non dovrebbero richiedere di spostare gli Obj in memoria. Partendo poi
dall'ipotesi (giusta?) che la lista tenga all'interno automaticamente
tutti i puntatori in un modo simile a quello che facevo io nel caso
precedente.
Ora pero', se io volessi estrarre un elemento prendendomene il possesso?
Qualcosa del tipo:
std::list<Obj>::iterator a=...;
Obj*O=Lista.mollaelemento(a); //Nella mia idea l'elemento stesso viene
tolto dalla lista, senza che effettivamente ne venga chiamato il
costruttore di copia, come dovrebbe invece avvenire per un
std::vector<Obj>
Ho cercato, ma non ho trovato nulla.
Ho trovato splice, che pero' mette l'elemento in un'altra lista; secondo
me non dovrebbe differire troppo come implementazione.
Possibile che non ci sia???
Spero di essere stato chiaro; in caso contrario ci riprovero' :)
 bye
	av.

 Ora pero', se io volessi estrarre un elemento prendendomene il possesso?
Non puoi. D'altronde l'oggetto in questione potrebbe essere membro di una 
struttura più ampia, tramite la quale la lista è implementata.
Se trovi pericoloso gestire un container di puntatori, potresti considerare 
l'utilizzo dei cosidetti "smart pointer", come quelli disponibili 
nella libreria Boost:
 
http://www.boost.org/libs/smart_ptr/smart_ptr.htm
 
Max

   
http://www.boost.org/libs/smart_ptr/smart_ptr.htm
No, non posso. (Sigh!)
Il cliente per il quale scrivo gia' storce il naso se uso la STL,
figuriamoci se gli vado a proporre delle librerie addizionali. Aggiungi
a questo che il tutto va compilato con altri moduli che vanno in
conflitto con qualunque cosa, perche' sono fuori da ogni standard e
pieni di macro o amenicoli simili. In piu' si *deve* usare un
compilatore preistorico. (Evitiamo i commenti a riguardo, dico solo che
non e' stata una scelta/opera mia).
 bye
	av.

 figuriamoci se gli vado a proporre delle librerie addizionali. 
Allora, cercati una qualsiasi implementazione di puntatore 
reference-counted (di solito sono poche righe di codice) e usa quella. 
Oppure guardati il codice di quella di Boost (sono sempre poche righe) e 
riscrivila eliminando le eventuali dipendenze dal resto del codice di Boost.
Max

 riscrivila eliminando le eventuali dipendenze dal resto del codice di Boost.
Alla fine penso di aver risolto con un
std::vector<boost::shared_ptr<Obj> >.
Sperando di non incontrare problemi...
 bye & Thanks
	av.

 Vettore.erase(a);} e cosi' via.
Per non parlare del fatto che potrebbe venir lanciata un'eccezione nel
frattempo.
-- 
http://www.parashift.com/c++-faq-lite/
http://mindview.net/Books/DownloadSites
http://www.cppreference.com/