Newsgroup: it.comp.lang.c++
Titolo: STL vector

interessa. Non c'e' un metodo piu' furbo ?
Passagli l'indirizzo dell'elemento da cancellare ignorando gli
iteratori.
std::vector<int> v(10);
v.erase(&v[1]);
Ma non é la regola generale. Si puň fare solo con i container che
permettono l'accesso via indice ( quindi vector e deque).
Il Ghenio
---------
These are my parting words to you:
those who give up are doomed!

 < Anche un maiale puo' scalare una palma se adulato >
!!! :-))
--
Gerolamo

iteratori.
Non credo sia un sistema accettabile: nemmeno per std::vector
e' garantito che un iteratore sia un puntatore. Ottenere un
l'iteratore posizionato sull i-esimo elemento puoi pero' usare
   v.begin()+i
senza dover fare loop (e che risulta tanto efficiente quanto
&v[i] dove gli iteratori sono semplici puntatori).
Ci sono ambienti in cui anche gli iteratori di vector sono
oggetti complessi quando compili in modalita' "debug" (in
modo da segnalare sconfinamenti e invalidazioni).
HTH
Andrea

 permettono l'accesso via indice ( quindi vector e deque).
non e' portabile. L'espressione &v[1] restituisce un *puntatore* 
all'elemento di indice 1, non un iteratore. Molto spesso gli iteratori 
di std::vector sono in effetti dei puntatori e quindi il codice qua 
sopra puo' funzionare; ma alcune implementazioni possono decidere di 
rendere std::vector<>::iterator una classe, e in quel caso &v[1] non 
restituisce piu' un iteratore.
Il modo migliore per ottenere l'iteratore e', come e' gia' stato detto:
        v.begin() + indice;
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it

 rendere std::vector<>::iterator una classe,
Siamo daccordo sul fatto che la erase vuole un iterator che non e' detto
che sia T* ma ricordiamo anche che lo standard dice che un iterator deve
avere la semantica di un puntatore.
Ciao
Gaetano
--
#exclude <windows>
printf("\t\t\b\b\b\b\b\b");.
printf("\t\t\b\b\b\b\b\b");
-- 
Posted from 
nts-03.mm.eutelsat.org
 [194.214.173.15] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 iterator deve avere la semantica di un puntatore.
alla fine non ho capito; concordi con me, vero?


 alla fine non ho capito; concordi con me, vero?
Sono per usare un iteratore come se fosse un puntatore ma non il contrario.


   v.begin()+i
In effetti é giusto quanto dite,e l'implementazione di std::vector del
djgpp si comporta proprio in tal modo.
Sono stato confuso da una frase dello Stroustrup che segnala la
validità del sistema che ho esposto nel post precedente, ma solo per
l'implementazione più ovvia di std::vector.


 contrario.
infatti: io non ho mai sostenuto il contrario.
Per concludere: un puntatore e` a tutti gli effetti un iteratore (ad 
accesso casuale), ma non sempre un iteratore ad accesso casuale e` un 
puntatore.


 puntatore.
Il contrario.
Ciao
Gaetano.


 permettono l'accesso via indice ( quindi vector e deque).
no: con deque non funzionerebbe. E' già tanto se funziona con vector.
Fai come ha detto Antonio che è meglio.
--
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

 Il contrario.
No. Ha ragione antonio.
Un iteratore NON E' obbligato ad essere un puntatore (anche se ne
soddisfa la semantica).
Un puntatore E' anche un iteratore.


 Un puntatore E' anche un iteratore.
Un Iteratore ha la semantica di un puntatore: "Puo essere usato come se 
fosse un puntatore".
Un puntatore non puo essere usato come se fosse un iteratore ( l'iteratore
potrebbe essere una classe).
Ciao
Gaetano
--
#exclude <windows>
printf("\t\t\b\b\b\b\b\b");.
printf("\t\t\b\b\b\b\b\b");
-- 


 potrebbe essere una classe).
Non facciamo confusione.
Uno specifico puntatore non può essere convertito in uno specifico
iteratore e neppure viceversa a meno che tale conversione non sia
appositamente codificata nella classe che fa da iteratore.
Ma "iteratore" e "puntatore" non sono due tipi. Sono due astrazioni.
Si dice puntatore una variabile che contiene l'indirizzo di un oggetto
di un certo tipo. Il linguaggio definisce le operazioni possibili con i
puntatori.
Si dice iteratore qualunque oggetto il cui tipo (il cui ESATTO tipo)
soddisfa un certo numero di "requirements", fra cui buona parte della
semantica di base dei puntatori. Tutti i tipi puntatore soddisfano
questi requirements (tranne i puntatori a void).
In generale mentre il tipo "reale" del puntatore è conosciuto, il tipo
"reale" dell'iteratore è parametrico (templated). Proprio perchè per
parlare di puntatore bisogna conoscere con esattezza il tipo mentre per
parlare di iteratore è sufficiente che siano soddisfatti alcuni
requirements.
Qualunque template che preveda dei parametri "iteratori" può SEMPRE
essere istanziato usando come tipo "reale" dell'iteratore un qualunque
puntatore non costante (tranne i puntatori a void, ovviamente).


 Il contrario.
???
se ho:
        int a[5];
&a[0], &a[1], ... sono tutti iteratori ad accesso casuale.
Se ho:
        std::vector<int> a(5);
        int* p = a.begin();
Il codice qua sopra e` sbagliato, o per lo meno non portabile.


 Il codice qua sopra e` sbagliato, o per lo meno non portabile.
Non compilerebbe se la classe iterator fosse fatta male.
Supponi che l'iterator fosse cosi' implementato:
template <class T>
class Iterator {
    T value;
    ......    
public:
    ......
    operator T*() { return &value; }
};
il tuo codice sarebbe legale.
Ovviamente ho omesso tutti gli altri requisiti.
Quando lo standard dice che iterator deve avere la 
semantica di un puntatore penso che voglia anche dire
deve comportarsi come se fosse un puntatore e quindi
assegnabile ad un puntatore.
Ciao
Gaetano
--
#exclude <windows>
printf("\t\t\b\b\b\b\b\b");.
printf("\t\t\b\b\b\b\b\b");
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG


Boh, o sto fraintendendo quello che dici, o stai dicendo qualcosa di
inesatto.
Quando si dice che un iteratore deve avere una certa sematica si intende che
certe determinate espressioni devono essere definite e restituire
determinati tipi di risultati.
Quali sono queste espressioni dipende dal tipo di iteratore che stiamo
considerando (nel caso si std::vector si tratta di iteratore ad accesso
casuale).
In nessun caso però è richiesto che un iteratore sia assegnabile a un T*.
Max

 determinati tipi di risultati.
Dice che un Iterator deve avere la semantica di un puntatore.
E per me semantica vuol dire (oltre ad avere l'operatore-> definito ed
altre cose) anche deve essere possibile assegnarlo ad un puntatore.
Ciao
Gaetano.


 altre cose) anche deve essere possibile assegnarlo ad un puntatore.
In generale non e' detto, tanto e' vero che si usa l'idiom:
vector<T>::iterator i;
T * p = &*i;
Ciao,
Nicola

 altre cose) anche deve essere possibile assegnarlo ad un puntatore.
Assolutamente no. Lo standard non dice che un iteratore deve avere TUTTA
la semantica di un puntatore. La semantica di un itaratore č
perfettamente definita dallo standard. Inoltre tale sementica si
riferisce al tipo esatto dell'iteratore e non si estende automaticamente
ai suoi derivati. Tanto per farti un esempio se "pointer" č un tipo
puntatore, allora "const pointer&" ha ancora tutta la semantica di un
puntatore salvo che non č modificabile. Invece se "iteratore" č un tipo
iteratore, "const iteratore&" potrebbe benissimo non soddisfare i
requirements di un iteratore. Semplicemente per il fatto che non č piů
lo stesso tipo ("T" e "const T&" sono due tipi diversi).


 wrote in message

Per riassumere:
1) Se un iteratore 'i' supporta (*i).m allora
   deve altrettanto funzionare i->m con la stessa
   semantica.
Sfatato quindi il fatto che i->m non e' portabile.
(nessuno lo ha detto qui ma si sente dire in giro).
2) Una funzione template che funziona con un iterator
   deve funzionare con un puntatore.
Questo significa che dovunque (parte publica) c'e' un 
iteratore posso sostituirci il puntatore "equivalente".
In effetti non dice il contrario, cioe' non dice che
posso sostiture un puntatore con un iteratore;
Da questo si deduce che e' piu' esatto dire che un puntatore
"estende il concetto" di iteratore.
A me suonava meglio il contrario.
3) E' vero che si usi l'idiom
   vector<T>::iterator i;
   T * p = &*i;
ma non capisco allora perche' a questo punto non sia 
lecito inserire come requisito ad un iteratore il fatto di avere
definito 
   operator T*() { return &*this; } // o equivalente
???
Ciao
Gaetano.
PS. Che palle sto fatto che ora MailGate funzioni in maniera
    email post + conferma..... con bug .....


 ???
Perche' le conversioni implicite sono spesso pericolose. Ad esempio
possono portare ad uno qualsiasi tra i due comportamenti mostrati nella
funzione di esempio piu' sopra senza che il programmatore se ne renda
conto.
Ciao,
Nicola

    operator T*() { return &*this; } // o equivalente
Perchè non per tutti gli iteratori l'uso di operator* è libero (e quindi
non sarebbe chiaro come gestire la conversione).
Pensa ad un output iterator. In un output iterator quell'idioma (e
quella conversione) non hanno senso. Per un output iterator "i" non è
definito "*i" se non a sinistra di un uguale.
Pensa ad un input iterator per un tipo T che non è assegnabile (per gli
input iterator il tipo può non essere assegnabile).
Quell'idioma lo si usa quando serve prendere l'indirizzo di un oggetto
contenuto in un container. Ma gli iteratori non sempre fanno riferimento
ad un container. L'idioma funziona solo se l'iteratore è come minimo un
forward iterator.
