¿Cómo mostrar los contenidos del mapa?

Question

Tengo un mapa

map < string , list <string> > mapex ; list<string> li; 

cómo mostrar los elementos del mapa encima de la consola.

Answer 1

Bueno, depende de cómo desea mostrarlos, pero siempre se puede recorrer fácilmente:

typedef map<string, list<string>>::const_iterator MapIterator; 
for (MapIterator iter = mapex.begin(); iter != mapex.end(); iter++) 
{ 
    cout << "Key: " << iter->first << endl << "Values:" << endl; 
    typedef list<string>::const_iterator ListIterator; 
    for (ListIterator list_iter = iter->second.begin(); list_iter != iter->second.end(); list_iter++) 
     cout << " " << *list_iter << endl; 
} 

Answer 2

me gustaría probar el siguiente

void dump_list(const std::list<string>& l) { 
    for (std::list<string>::const_iterator it = l.begin(); l != l.end(); l++) { 
    cout << *l << endl; 
    } 
} 

void dump_map(const std::map<string, std::list<string>>& map) { 
    for (std::map<string,std::list<string>>::const_iterator it = map.begin(); it != map.end(); it++) { 
    cout << "Key: " << it->first << endl; 
    cout << "Values" << endl; 
    dump_list(it->second); 
} 

Answer 3

estoy un poco fuera de tema aquí ...

Supongo que desea volcar el contenido del mapa para la depuración. Me gustaría mencionar que la próxima versión de gdb (versión 7.0) incluirá un intérprete de python que será utilizado por gcc libstdC++ para proporcionar impresoras stl bonitas. Aquí está un ejemplo para su caso

#include <map> 
    #include <map> 
    #include <list> 
    #include <string> 

    using namespace std; 

    int main() 
    { 
    typedef map<string, list<string> > map_type; 
    map_type mymap; 

    list<string> mylist; 
    mylist.push_back("item 1"); 
    mylist.push_back("item 2"); 
    mymap["foo"] = mylist; 
    mymap["bar"] = mylist; 

    return 0; // stopped here 
    } 

que se traduce en

(gdb) print mymap 
$1 = std::map with 2 elements = { 
    ["bar"] = std::list = { 
    [0] = "item 1", 
    [1] = "item 2" 
    }, 
    ["foo"] = std::list = { 
    [0] = "item 1", 
    [1] = "item 2" 
    } 
} 

Yay!

Answer 4

Otra forma, utilizando <algorithm>:

void printPair(const pair<string, list<string> > &p) 
{ 
    cout << "Key: " << p.first << endl; 
    copy(p.second.begin(), p.second.end(), ostream_iterator<string>(cout, "\n")); 
}  
for_each(mapex.begin(), mapex.end(), printPair); 

Programa de prueba:

#include <iostream> 
#include <map> 
#include <list> 
#include <iterator> 
#include <algorithm> 
using namespace std; 

void printPair(const pair<string, list<string> > &p) 
{ 
    cout << "Key: " << p.first << endl; 
    copy(p.second.begin(), p.second.end(), ostream_iterator<string>(cout, "\n")); 
} 

int main() 
{ 
    map<string, list<string> > mapex; 

    list<string> mylist1; 
    mylist1.push_back("item 1"); 
    mylist1.push_back("item 2"); 
    mapex["foo"] = mylist1; 
    list<string> mylist2; 
    mylist2.push_back("item 3"); 
    mylist2.push_back("item 4"); 
    mylist2.push_back("item 5"); 
    mapex["bar"] = mylist2; 

    for_each(mapex.begin(), mapex.end(), printPair); 
} 

Answer 5

Update (Volver al futuro): con C++ 11 para los lazos basados ​​en la gama -

std::map<Key, Value> m { ... /* initialize it */ ... }; 

for (const auto &p : m) { 
    std::cout << "m[" << p.first << "] = " << p.second << '\n'; 
} 

Answer 6

Puede escribir una función sobrecargada bastante genérica, que es válida para dos propósitos:

1. Funciona con cualquier map.
2. Permite el uso de <<.

La función es

template<class key_t, class value_t> 
ostream& operator<<(ostream& os, const map<key_t, value_t>& m) { 
    for (typename map<key_t, value_t>::const_iterator it = m.begin(); 
      it != m.end(); it++) { 
     os << "Key: " << it->first << ", Value: " << it->second; 
    } 
    return os; 
} 

cout << funcionará con cualquier map para los que << se define para typename s key_t y value_t. En su caso, esto no está definido para value_t (= list<string>), por lo que también debe definirlo. En un espíritu similar, puede utilizar

template<class T> 
ostream& operator<<(ostream& os, const list<T>& l) { 
    for (typename list<T>::const_iterator it = l.begin(); it != l.end(); it++) { 
     os << "\"" << *it << "\", "; 
    } 
    return os; 
} 

Por lo tanto, es posible que:

1. Añadir estas dos funciones.
2. Agregue los prototipos donde sea necesario.
3. Use using namespace std; (o agregue std:: según sea necesario).
4. Uso, p.,
   cout << mapex << endl;
cout << li << endl;

recordar que si hay algún otro candidato viable para los << s acaba de definir (que tomo no hay, de lo contrario es probable que no haría esta pregunta), puede tener prioridad sobre los actuales.