Newsgroup: it.comp.lang.c++
Titolo: come prendere un iterator che punta all'ultimo elemento

per fare questo di solito scrivo, ad esempio
list<int>::iterator it = MyList.end();
--it;
ma non si può fare in una sola riga? se scrivo MyList.end() - 1 non
tutti gli iteratori vanno bene (ad esempio, per le liste non vanno
bene)
-- 
]\/[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

 tutti gli iteratori vanno bene
Provato con 
... = --MyList.end()
? 
-- 
Luc


wrote:

ovvio... talmente ovvio che non c'avevo pensato... :-D


>... = --MyList.end()
Mi sbaglio se credo che questo tipo di approccio potrebbe fallire in 
qualche caso?
Mi sembra di ricordare che si può fare in questo modo solo su un random 
iterator.
Se ad esempio come struttura si utilizza una std::slist la cosa non 
dovrebbe andare bene, giusto?
La mia non è una critica alla risposta di Luc ma solo una domanda.
Proverò sul mio nuovo gcc nonappena a casa.
-- 
Domenico Testa - Studente

 iterator.
No, si può fare con qualunque iteratore bidirezionale, a condizione che 
*non* sia un typedef di un puntatore, poiché in questo caso non potresti 
applicare l'operatore '--' al valore temporaneo restituito da end().
Max

 ... = --MyList.end()
Se MyList e' in realta' un std::vector e la sua implementazione usa
puntatori come iteratori dei vector, non funziona: tenta di modificare
un valore temporaneo.
Ciao,
Nicola

On 16 Feb 2004 07:36:48 -0800, Nicola....@ObjectWay.it (Nicola
Musatti) wrote:

ma un Random Access Iterator, come quello dei std::vector, non
dovrebbe consentire gli operatori ++ e --?


 dovrebbe consentire gli operatori ++ e --?
Il problema non e' il Random Access Iterator, quanto il fatto che i
puntatori sono tipi fondamentali, ed i valori temporanei di tipi
fondamentali non sono modificabili.
Ciao,
Nicola

fondamentali non sono modificabili.
quindi stai parlando di implementazione del compilatore, non di
linguaggio?


 linguaggio?
Sto parlando della scelta, legittima secondo lo standard, di
implementare gli iteratori di std::vector con dei semplici puntatori.
In generale i valori temporanei non sono modificabili, ma e' comunque
possibile chiamare su di loro funzioni membro non const. Questo fa si
che l'espressione
--v.end();
non e' valida nel caso di un puntatore, perche' si tratta del
tentativo di modificare il puntatore temporaneo restituito dalla
funzione; e' invece valida per un'istanza di una classe, perche' in
quel caso '--' e' una funzione membro non const come qualsiasi altra.
Ciao,
Nicola

quel caso '--' e' una funzione membro non const come qualsiasi altra.
io ho capito questo discorso dell'implementazione, ma mi chiedo se sia
lecito implementare gli iteratori come puntatori, considerando che lo
standard impone agli iteratori un certo comportamento (o lo fa solo la
stl di sgi?)


 comportamento (o lo fa solo la stl di sgi?)
Lo standard dice che gli iteratori hanno l'operatore -- (come gli
interi, i puntatori, ...), ma non dice che un iteratore temporaneo
deve essere modificabile.
     Mauro

deve essere modificabile.
beh... dice il contrario?
se mi si dice un iteratore ha l'operatore -- e non mi si dice altro,
io capisco che TUTTI gli iteratori hanno l'operatore --, non faccio
distinzione tra temporaneo o non temporaneo...


 non faccio distinzione tra temporaneo o non temporaneo...
Il C++ fa distinzione.
      Mauro

 distinzione tra temporaneo o non temporaneo...
Certo, perň se quel temporaneo č di un tipo built-in, c'č una la regola che 
prescrive che non sia modificabile.
Ad ogni modo, gli unici iteratori nella libreria standard implementabili 
come semplici puntatori sono quelli di std::vector e di std::string. In 
molte implementazioni, tra cui le versioni piů recenti della stdc++ del 
gcc, sě č preferito *non* usare tipi built-in nemmeno in questi casi.
Max