Newsgroup: it.comp.lang.c++
Titolo: iteratori, mappe e overloading

salve a tutti,
due domande ...
1)
c'e' qualche differenza nelle <string> tra l'operatore += e la funzione
append(), o il primo e' l'overloading di append(str.begin(), str.end()) ? e se
e' cosi', anche gli altri operatori sono overloading di funzioni ?
2)
come mai 
vector<int> the_vector;
vector<int>::iterator the_iter;
....
while (the_iter < the_vector.end())
{
....
}
funziona e
map<int, string> miamappa;
map<int, string>::iterator myit=miamappa.begin();
....
while (myit < miamappa.end())
{
....
}
mi da
no match for `_Rb_tree_iterator<pair<const int,basic_string<char,s
tring_char_traits<char>,__default_alloc_template<false,0> > >,pair<const
int,basic_string<char,string_char_traits<char>,__default_alloc_template
<false,0> > > &, pair<const int,basic_string<char,string_char_traits<char>,
__default_alloc_template<false,0> > > *> & < _Rb_tree_iterator<pair<const
int,basic_string<char,string
_char_traits<char>,__default_alloc_template<false,0> > >,pair<const
int,basic_string<char,string_char_traits<char>,__default_alloc_template
<false,0> > > &,pair< const
int,basic_string<char,string_char_traits<char>,__default_alloc_template<fa
lse,0> > > *>'
e
myit=miamappa.begin();
/* funziona */
for (myit=miamappa.begin(); myit!=miamappa.end(); myit++)
	cout << myit->first << " " << myit->second << endl; */
/* non stampa niente !! */
while (myit != miamappa.end())
{
	cout << myit->first << " " << myit->second << endl;
	myit++;
}
grazie anticipate ...
-- 
#include <stdio.h>
int main(void){char c[]={10,65,110,116,111,110,105,111,32,98,97,114,98,111,110,
101,32,60,104,105,110,100,101,109,105,116,64,116,105,115,99,97,108,105,110,101,
116,46,105,116,62,10,10,0};printf("%s",c);return 0;}

 while (myit != miamappa.end())
Dopo il primo ciclo 'myit' vale 'end()'. Se non lo riporti a 'begin()'...
Max

 Max
ciao e grazie per l'aiuto ...


Antonio barbone wrote:

L'iteratore punta all'elemento begin(). Se inserisci un nuovo valore, non è
detto che il vecchio begin() coincida con il nuovo begin().
Devi pensare alla struttura ad albero con cui è (solitamente) realizzata la
map.
A proposito, attento che è rischioso inserire in un contenitore nuovi
elementi dopo aver inizializzato degli iteratori.
Se inizializzi l'iteratore prima del ciclo while, invece, l'iterazione
funziona correttamente, visualizzando tutti gli elementi.
Ciao

 elementi dopo aver inizializzato degli iteratori.
Che significa "rischioso"? Per ogni tipo di container lo Standard  
specifica con precisione quali operazioni invalidano gli iteratori e quali 
no. 
Nel caso di 'std::map', ad esempio, nessuna operazione di inserimento 
invalida iteratori esistenti, mentre le operazioni di rimozione invalidano 
esclusivamente gli iteratori che puntano ad elementi rimossi.
Max

 Max
Sì, mi sono espresso male.
Sono d'accordo con te che gli iteratori restano validi, ma non le posizioni.
Forse questo esempio può spiegare quello che intendevo: l'iteratore è sempre
valido, solo che non punta al vero begin della map, ma alla "begin
vecchia".
Per esempio, in questo caso, sono stampati solo i valori 3 e 4.
#include <iostream>
#include <map>
using namespace std;
int main(int argc, char *argv[])
{
  map<int, int> m;
  m[3] = 2;
  m[4] = 1;
  map<int, int>::iterator itr(m.begin());
  m[1] = 5;
  m[2] = 6;
  while(itr != m.end())
  {
     cout << itr->first << endl;
     ++itr;
  }
  return EXIT_SUCCESS;
}
Paolo