Wie kann ich die Iteration über eine STL-Karte in eine STL-map?

Habe ich eine STL-map-definition wie folgt:

map<string, map<int, string> > info;

Ich Durchlaufen, die Karte mit dem folgenden code:

for( map<string, map<int, string> >::iterator ii=info.begin(); ii!=info.end(); ++ii){
    for(map<int, string>::iterator j=ii->second.begin(); j!=ii->second.end();++j){
        cout << (*ii).first << " : " << (*j).first << " : "<< (*j).second << endl;
    }
}

Ist dies die richtige Art und Weise zu Durchlaufen, oder gibt es eine bessere Möglichkeit, dies zu tun? Der obige code funktioniert für mich, aber ich bin auf der Suche nach einer eleganten Lösung.

  • Tatsächlich Iteration über alle Einträge der äußeren anzeigen und alle inneren Landkarten als gut, es gibt keine "bessere" Lösung würde ich sagen. Zwei geschachtelte Schleifen, kein problem.
  • Als Nebeneffekt der Frage in Bezug auf Eleganz, was falsch mit der -> Betreiber?
  • es ist nichts falsch oder unelegent über das code.. es ist nur so, dass ich thot gibt es vielleicht einen besseren Weg...
InformationsquelleAutor Prasanth Madhavan | 2010-12-23
  1. 16

    Dies ist korrekt, es fehlen lediglich noch ein paar typedef und Lesbarkeit Verbesserungen :

    typedef std::map<int, std::string> inner_map;
typedef std::map<std::string, inner_map> outer_map;

for (outer_map::iterator i = outerMap.begin(), iend = outerMap.end(); i != iend; ++i)
{
    inner_map &innerMap = i->second;
    for (inner_map::iterator j = innerMap.begin(), jend = innerMap.end(); j != jend; ++j)
    {
        /* ... */
    }
}
    • Könnte verwenden Sie const-Iteratoren auch in diesem Fall nicht, dass es macht einen großen Unterschied.
    InformationsquelleAutor icecrime
  2. 12

    Wenn C++11 verfügbar ist, können Sie verwenden range for Schleife:

    for(auto &i: info) {
    for(auto &j: i.second) {
        /* */
    }
}

    Wenn nur C++11 auto verfügbar ist:

    for( auto i=info.begin(); i!=info.end(); ++i) {
   for( auto j=i->second.begin(); j!=i->second.end(); ++j) {
       /* */
   }
}

    Nicht, wenn Sie die BOOST-es ist BOOST_FOREACH:

    typedef std::map<int, std::string> inner_map;
typedef std::map<std::string, inner_map> outer_map;

outer_map outer;

BOOST_FOREACH(outer_map::value_type &outer_value, outer){
    BOOST_FOREACH(inner_map::value_type &inner_value, outer_value->second){
        /* use outer_value and inner_value as std::pair */
    }
}
    InformationsquelleAutor Juraj Blaho
  3. 1

    Während es ist nicht klar, welches problem Sie lösen, indem er eine Karte innerhalb einer Karte, ich glaube nicht, dass es einen besseren Weg, die Iteration über alle Elemente ohne Verwendung dieser Iteratoren. Die einzige Sache, die Sie tun können, zu verbessern die Lesbarkeit des Codes ist die Verwendung von Typdefinitionen auf die template-Typen.

    Allerdings wird es nicht eine bessere Idee, um zu definieren, Ihre map als

    multimap <string, MyClass>

    wo MyClass ist definiert als ein paar von integer-und eine string sowie eine toString () - Methode schreibt den Inhalt, etc?

    InformationsquelleAutor Jaywalker
  4. 1

    Wenn c++11 verfügbar ist, können wir die stl-Algorithmus for_each-und lambda-Funktionen, um eine elegante Lösung

    typedef map<int, string> INNERMAP;
typedef map<string, INNERMAP> OUTERMAP;

OUTERMAP theMapObject;
//populate the map object

    //Durchlaufen der map-Objekt jetzt

    std::for_each(theMapObject.cbegin(), theMapObject.cend(), 
    [](const OUTERMAP::value_type& outerMapElement)
{
    //process the outer map object
    const INNERMAP& innerMapObject = outerMapElement.second;
    std::for_each(innerMapObject.cbegin(), innerMapObject.cend(), 
        [](const INNERMAP::value_type& innermapElemen)
    {
        //process the inner map element
    });
});
    InformationsquelleAutor Santosh Chauhan
  5. 0

    Wenn Sie möchten, Durchlaufen beide Karten, dann die Art und Weise Sie präsentiert wird, ist der beste Weg. Nun, wenn gibt es etwas bestimmtes, das Sie tun möchten, dann werden Sie vielleicht besser mit Hilfe einer Funktion aus Algorithmus header.

    InformationsquelleAutor BЈовић
  6. 0

    Wenn Sie Zugang zu C++11 Funktionen, dann range-basierte for-Schleifen, wie vorgeschlagen, Juraj Blaho Antwort scheinen die meisten lesbar option für mich. Allerdings, wenn C++17 für Sie verfügbar ist, dann können Sie strukturierte Bindungen zusammen mit den loops zur weiteren Erhöhung der Lesbarkeit, wie Sie können loszuwerden, alle first und second Mitglieder:

    std::map<std::string, std::map<int, std::string>> info;

for (const auto &[k1, v1] : info) {
    for (const auto &[k2, v2] : v1) {
        std::cout << k1 << " : " << k2 << " : " << v2 << std::endl;
    }
}

    Code auf Coliru

    InformationsquelleAutor honk
Schreibe einen Kommentar