c++ - que - ¿Cómo mostrar los contenidos del mapa?

que es un mapa mental

Question

Tengo un mapa

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

cómo mostrar los elementos del mapa anterior en la consola.

Answer 1

Actualización (Regreso al futuro): con C ++ 11 basado en rango para bucles -

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

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

Answer 2

Bueno, depende de cómo quieras mostrarlos, pero siempre puedes iterarlos 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 3

Estoy un poco fuera de tema aquí ...

Supongo que quieres 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) tendrá un intérprete de Python incorporado que será utilizado por gcc libstdc ++ para proporcionar impresoras bonitas de stl. Aquí hay 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
  }

lo que resulta 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"
  }
}

¡Hurra!

Answer 4

Otra forma, usando <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

Probaria lo 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 6

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

1. Funciona con cualquier map .
2. Permite utilizar << .

La funcion 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 el cual << 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 tiene que definirlo. En un espíritu similar, puedes usar

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, usted puede:

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

Recuerde que si hay algún otro candidato viable para los << s que se acaban de definir (que asumo que no existe, de lo contrario, es probable que no haga esta pregunta), puede tener prioridad sobre los actuales.