Newsgroup: it.comp.lang.c++
Titolo: Liste e rimozione elementi

Visto che le poche righe di codice che ho scritto crashano, mi e' venuto un
dubbio: non e' che se mi trovo dentro ad un ciclo che scorre gli elementi di
una lista e ad un certo punto devo eliminarne uno, si incasina tutto perche'
modifico la lista su cui sto ciclando ?
Cioe', una roba di questo tipo e' lecita ?
for (Iter lista.begin(); i!= lista.end(); i++)
{
            [..]
            lista.remove((*i));
}
Se cosi' non si puo' c'e' un altro modo ?
--
Le Sabbie del Tempo scorrono ancora!
Vieni a giocare su:
  telnet://
anacronia.luda.it:4000

 modifico la lista su cui sto ciclando ?
L'argomento è stato discusso in modo abbastanza approfondito in un lungo
thread su questo stesso NG circa un mese fa:
 
http://groups.google.com/groups?hl=it&th=72a5bcf62cb15162
Max

 Se cosi' non si puo' c'e' un altro modo ?
for (Iter i =  lista.begin(); i =lista.end();  /* non si incrementa */ ) {
    if ( devo rimuovere i ) {
        lista.erase(i++);
    }
    else {
        ++i;
    }
}
Ciao
Gaetano.
-- 
Posted from 
nts-03.mm.eutelsat.org
 [194.214.173.15] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 }
Dovrebbe andare. Ma non mi piace. Io consiglio:
 i = lista.erase(i);
invece di
 lista.erase(i++);
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

  i = lista.erase(i);
A te piace di piu' la seconda ma io non la metterei in termini di gusti.
La mia forma funziona perche' si usa una lista, se si decide di cambiare
container sarebbe un disastro, ed proprio questo disastro che ti porterebbe
a rivalutare l'usare un altro metodo che comunque per motivi di efficienza
non
e'  i = lista.erase(i) a meno che tu non ne debba eliminare un paio.


 e'  i = lista.erase(i) a meno che tu non ne debba eliminare un paio.
Mumble. Gusti a parte, non ho capito bene cosa intendi.
Entrambe i metodi funzionano con qulunque sequenza (ricordando che le
sequenze sono un sottoinsieme dei container). Un container che non è una
sequenza ... non ha una erase che accetta un iteratore (e neppure
avrebbe senso che lo avesse).
In termini di efficienza ... io dico che la differenza è piccolissima e
che la mia versione è più efficiente.


 sequenze sono un sottoinsieme dei container). 
Con un vector il mio metodo non funzionerebbe. Ti si crasherebbe
il programma (credo).


 il programma (credo).
Mumble. Hai ragione. Motivo in più per preferire il mio (oltre al fatto
che è in teoria lievissimamente più efficiente).
Nota: con vector e deque il tuo non va bene non perchè non sia corretto
quello statement (non è li che creasha) ma perchè dopo la erase tutti
gli iterator devono essere considerati invalidi (anche se tecnicamente
quelli che riferiscono a elementi precedenti sono ancora validi e quelli
che riferiscono a elementi successivi sono validi ma puntano ad un altro
elemento, l'unico che diventa effettivamente invalido è v.end(), ma
comunque li devi considerare TUTTI invalidi).


comunque li devi considerare TUTTI invalidi).
Lo standard cosa dice esattamemente? E` possibile che quelli prima
diventino invalidi?
-- 
                    Marco Barisione (ICQ 84277092)
Se sei interessato alla creazione di un newsgroup generico in cui si
possa parlare di quei linguaggi di programmazione senza un gruppo
apposito vota per it.comp.lang su it.news.votazioni.

 quello statement (non è li che creasha)
crasha al prossimo riferimento ad i infatti.
Ciao
Gaetano.


 wrote in message
news:5h2h1ucnhun3052dp...@4ax.com...

--


 diventino invalidi?
No! Per il vector sono invalidi solo reference e iterator dal punto
della erase in poi. Per list invece sono ancora tutti validi (tranne
quello eliminato). Per deque lo standard dice che se l'erase è in mezzo
sono invalidati tutti mentre se è all'inizio o alla fine è invalidato
solo quello eliminato. E IMO questo non è vero. Nel senso che facendo
l'erase dell'ultimo elemento, ovvero d.erase(d.end()-1), oltre ad
invalidare d.end()-1 si invalida anche d.end(). Magari uno di questi
giorni vado a vedere se c'è un issue aperto in proposito. Ora non ho
voglia (nelle ultime due notti ho dormito 4 ore in tutto!).


crasha al prossimo riferimento ad i infatti.
Per il vector non dovrebbe crashare ma solo fare cose diverse da quelle
che ti aspetti (in pratica è come se l'iteratore fosse stato avanzato
una volta di troppo). A meno che tu non abbia cancellato uno degli
ultimi due elementi. Nel qual caso l'itratore è invalido (se hai
cancellato l'ultimo) oppure valido ma non dereferenziabile (in altre
parole è v.end()) se hai cancellato il penultimo. Ovviamente per lo
standard l'iteratore è invalido punto e basta. Ma in realtà (a meno di
HW strani) le cose stanno come ho detto.


 Perchè mai?
perche' tutti gli elementi dopo i vengono ricopiati "verso sinistra"
per rimpiazzare il buco creato.


per rimpiazzare il buco creato.
Ok. Io avevo capito che non volevi usare quella sintasi, non che non
volevi usare la erase. Per questo mi chiedevo cosa volevi dire.
