¿Cómo recorrer un mapa de mapas en C++?

Question

¿Cómo puedo recorrer un std::map en C++? Mi mapa se define como:

std::map< std::string, std::map<std::string, std::string> > 

Por ejemplo, este posee los datos de la siguiente manera:

m["name1"]["value1"] = "data1"; 
m["name1"]["value2"] = "data2"; 
m["name2"]["value1"] = "data1"; 
m["name2"]["value2"] = "data2"; 
m["name3"]["value1"] = "data1"; 
m["name3"]["value2"] = "data2"; 

Como puedo bucle a través de este mapa y acceder a los diferentes valores?

Answer 1

pregunta antiguo, pero las respuestas restantes son anticuados como de C++ 11 - puede usar un ranged based for loop y simplemente hacer:

std::map<std::string, std::map<std::string, std::string>> mymap; 

for(auto const &ent1 : mymap) { 
    // ent1.first is the first key 
    for(auto const &ent2 : ent1.second) { 
    // ent2.first is the second key 
    // ent2.second is the data 
    } 
} 

esto debería ser mucho más limpio que las versiones anteriores, y evita copias innecesarias.

Algunos favorecen la sustitución de los comentarios con definiciones explícitas de variables de referencia (que conseguir optimizados de inmediato si no se utiliza):

for(auto const &ent1 : mymap) { 
    auto const &outer_key = ent1.first; 
    auto const &inner_map = ent1.second; 
    for(auto const &ent2 : inner_map) { 
    auto const &inner_key = ent2.first; 
    auto const &inner_value = ent2.second; 
    } 
} 

Answer 2

Puede usar un iterador.

typedef std::map<std::string, std::map<std::string, std::string>>::iterator it_type; 
for(it_type iterator = m.begin(); iterator != m.end(); iterator++) { 
    // iterator->first = key 
    // iterator->second = value 
    // Repeat if you also want to iterate through the second map. 
} 

Answer 3

for(std::map<std::string, std::map<std::string, std::string> >::iterator outer_iter=map.begin(); outer_iter!=map.end(); ++outer_iter) { 
    for(std::map<std::string, std::string>::iterator inner_iter=outer_iter->second.begin(); inner_iter!=outer_iter->second.end(); ++inner_iter) { 
     std::cout << inner_iter->second << std::endl; 
    } 
} 

o más agradable en C++ 0x:

for(auto outer_iter=map.begin(); outer_iter!=map.end(); ++outer_iter) { 
    for(auto inner_iter=outer_iter->second.begin(); inner_iter!=outer_iter->second.end(); ++inner_iter) { 
     std::cout << inner_iter->second << std::endl; 
    } 
} 

Answer 4

hacer algo como esto:

typedef std::map<std::string, std::string> InnerMap; 
typedef std::map<std::string, InnerMap> OuterMap; 

Outermap mm; 

...//set the initial values 

for (OuterMap::iterator i = mm.begin(); i != mm.end(); ++i) { 
    InnerMap &im = i->second; 
    for (InnerMap::iterator ii = im.begin(); ii != im.end(); ++ii) { 
     std::cout << "map[" 
        << i->first 
        << "][" 
        << ii->first 
        << "] =" 
        << ii->second 
        << '\n'; 
    } 
} 

Answer 5

uso std::map< std::string, std::map<std::string, std::string> >::const_iterator cuando mapa es const.

Answer 6

C++ 11:

std::map< std::string, std::map<std::string, std::string> > m; 
m["name1"]["value1"] = "data1"; 
m["name1"]["value2"] = "data2"; 
m["name2"]["value1"] = "data1"; 
m["name2"]["value2"] = "data2"; 
m["name3"]["value1"] = "data1"; 
m["name3"]["value2"] = "data2"; 

for (auto i : m) 
    for (auto j : i.second) 
     cout << i.first.c_str() << ":" << j.first.c_str() << ":" << j.second.c_str() << endl; 

de salida:

name1:value1:data1 
name1:value2:data2 
name2:value1:data1 
name2:value2:data2 
name3:value1:data1 
name3:value2:data2 

Answer 7

En C++ 17, usted será capaz de utilizar la función de "fijaciones estructurados", que le permite definir múltiples variables , con diferentes nombres, usando una sola tupla/par. Ejemplo:

for (const auto& [name, description] : planet_descriptions) { 
    std::cout << "Planet " << name << ":\n" << description << "\n\n"; 
} 

El original proposal (por luminarias Bjarne Stroustrup, Herb Sutter y Gabriel Dos Reis) es divertido de leer (y la sintaxis sugerida es mi humilde opinión más intuitivo); también está el proposed wording for the standard que es aburrido de leer, pero está más cerca de lo que realmente entrará.