Newsgroup: it.comp.lang.c++
Titolo: side effect di un erase sull'iterator parametro

Una curiosità su come vengano trattati gli iteratori passati come
parametro a una erase sul container vector:
vector<MyType> myvector;
//......
vector<MyType>::iterator iter = myvector.begin();
while(iter != myvector.end())
{
	//........
	myvector.erase(iter);
	iter++;
}
ORRORE! lo so che qualcuno di voi avrà sbottato così ;-) solo che era
molto funzionale alla domanda che sto per porvi. Cosa prevede lo
standard? Sia Borland che mingw32 incrementano l'iterator
*automaticamente* dopo l'erase, impedendo di fatto di poter utilizzare
un iteratore *logicamente* non più valido. In tal caso l'esempio di
cui sopra genera un errore nel caso debba essere cancellato proprio
l'ultimo elemento (iter è incrementato due volte ogni erase). Il
comportamento in sè non mi stupisce, mi sembra quasi naturale, solo
che mi sarei aspettato un comportamento più stupido.
il_t@sso
il_t...@yahoo.com

 standard?
Secondo lo standard l'elemento --- o gli elementi, se chiami il metodo
erase(first,last) --- viene rimosso e il distruttore chiamato.
Quello che ti e' sfuggito e' che il metodo erase() ritorna un valore:
questo e' un iteratore che o punta al prossimo elemento dopo l'ultimo
distrutto, o vale end(); basta usarlo per venir fuori dai guai.
Attento invece che non ci siano in giro altri iteratori sullo stesso
vettore e che possano puntare ad uno degli elementi distrutti!
-- 
Maurizio Loreti                      
http://wwwcdf.pd.infn.it/~loreti/mlo.html
Univ. of Padova, Dept. of Physics - Padova, Italy            
lor...@pd.infn.it

vettore e che possano puntare ad uno degli elementi distrutti!
Ecco, quello che mi chiedo! Se io ho due iteratori che puntano a due
oggetti *diversi* dopo una erase su uno di essi, il secondo iteratore
punta sempre allo stesso oggetto oppure vi è una riorganizzazione
degli stessi?
il_t@sso
il_t...@freemail.it

 degli stessi?
Potrebbe non puntare piu' allo stesso elemento o 
addirittura non puntare piu' a niente.
	Mauro

 degli stessi?
Dipende dall'implementazione della STL.  Distruggendo un elemento, non
e' detto che ci sia rilocazione degli altri; potrebbero solo essere
cambiati dei pointers.


 addirittura non puntare piu' a niente.
Sbagliato.  Come ho gia' detto, lo standard non garantisce la
correttezza degli iteratori solo se questi puntano ad oggetti che sono
stati distrutti.  Se puntano ad oggetti che precedono o seguono quelli
distrutti, continuano a rimanere validi ed a fornire quello che ti
aspetti se vengono incrementati.  Leggiti i messaggi del thread prima
di dire sciocchezze.


 di dire sciocchezze.
Nel thread si parlava di vector.
	Mauro


 Nel thread si parlava di vector.
Hai ragione - per la classe vector, size e' decrementato - e gli
elementi riallocati.  Gli iteratori che puntano ed elementi successivi
a quelli cancellati non sono piu' validi.  Sono io che ho detto una
sciocchezza; avevo in testa le liste.  Scusate!


cambiati dei pointers.
purtroppo per me avete ragione. Grazie dei suggerimenti. Sia con le
STL fornite con BCB4 che con quelle di mingw32 il comportamento è
quello descritto da voi.
il_t@sso
il_t...@freemail.it

 Leggiti i messaggi del thread prima di dire sciocchezze.
Scusa, ma perché rispondi sempre con questo tono? C'è qualcosa che
facciamo che ti infastidisce? Parliamone...
EMG


Per la verita` quasi tutti i docenti universitari che io ho conosciuto
rispondono con questo tono. Che sia una sorta di deformazione professionale ?
Marco Guidi
 

 rispondono con questo tono. Che sia una sorta di deformazione professionale ?
Intendi dire che Maurizio č un docente universitario? Se č cosě allora,
come preparazione, č sicuramente molto al di sopra della media dei suoi
colleghi...
EMG


Mi sembrava di averlo letto in un suo messaggio precedente, ma non vorrei
sbagliare.
Marco Guidi 



Beh basta andare all'URL nella sua firma.
il_t@sso
il_t...@freemail.it