Làm cách nào để lặp qua bản đồ bản đồ C++?

Question

Làm cách nào để lặp qua một số std::map trong C++? Bản đồ của tôi được định nghĩa là:

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

Ví dụ, đây chứa dữ liệu như thế này:

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

Làm thế nào tôi có thể lặp qua bản đồ này và truy cập vào các giá trị khác nhau?

Answer 1

Cũ câu hỏi nhưng câu trả lời còn lại là lỗi thời như của C++ 11 - bạn có thể sử dụng ranged based for loop và chỉ cần thực hiện:

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 
    } 
} 

điều này sẽ sạch hơn nhiều so với các phiên bản trước và tránh các bản sao không cần thiết.

Một số ủng hộ thay thế cho ý kiến ​​với các định nghĩa rõ ràng của biến tham chiếu (mà có được tối ưu hóa lập tức nếu không sử dụng):

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

Bạn có thể sử dụng trình lặp.

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; 
    } 
} 

hoặc đẹp hơn trong 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

Làm như thế này:

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

sử dụng std::map< std::string, std::map<std::string, std::string> >::const_iterator khi bản đồ là 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; 

đầu ra:

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

Answer 7

Trong C++ 17, bạn sẽ có thể sử dụng "ràng buộc có cấu trúc" tính năng, cho phép bạn xác định nhiều biến , với các tên khác nhau, sử dụng một bộ/cặp đơn. Ví dụ:

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

Các original proposal (bằng uy tín Bjarne Stroustrup, Herb Sutter và Gabriel Dos Reis) là thú vị để đọc (và cú pháp được đề xuất là IMHO trực quan hơn); đó cũng là số proposed wording for the standard mà nhàm chán để đọc nhưng gần gũi hơn với những gì thực sự sẽ đi vào.