Làm thế nào tôi có thể lặp qua bản đồ C ++ của bản đồ?

Làm thế nào tôi có thể lặp qua một std::maptrong C ++? Bản đồ của tôi được định nghĩa là:

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

Ví dụ, container ở trên 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 các giá trị khác nhau?

Câu hỏi cũ nhưng các câu trả lời còn lại đã lỗi thời kể từ C ++ 11 - bạn có thể sử dụng một vòng lặp dựa trên vòng lặp và chỉ cần làm:

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ố ưu tiên thay thế các nhận xét bằng các định nghĩa rõ ràng về các biến tham chiếu (được tối ưu hóa nếu không được 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;
  }
}

Bạn có thể sử dụng một trình vòng 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.
}

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

Với C ++ 17 (hoặc mới hơn), bạn có thể sử dụng tính năng "liên kết có cấu trúc", cho phép bạn xác định nhiều biến, với các tên khác nhau, bằng cách sử dụng một bộ / cặp duy nhất. Thí dụ:

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

Các đề xuất ban đầu (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à trực quan hơn IMHO); cũng có từ ngữ được đề xuất cho tiêu chuẩn nhàm chán để đọc nhưng gần hơn với những gì sẽ thực sự đi vào.

Làm một cái gì đó 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';
    }
}   

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

sử dụng std::map< std::string, std::map<std::string, std::string> >::const_iteratorkhi bản đồ là const.

Như einpoklum đã đề cập trong câu trả lời của họ , vì C ++ 17, bạn cũng có thể sử dụng các khai báo ràng buộc có cấu trúc . Tôi muốn mở rộng điều đó bằng cách cung cấp một giải pháp đầy đủ để lặp lại trên bản đồ bản đồ một cách thoải mái:

int main() {
    std::map<std::string, std::map<std::string, std::string>> m {
        {"name1", {{"value1", "data1"}, {"value2", "data2"}}},
        {"name2", {{"value1", "data1"}, {"value2", "data2"}}},
        {"name3", {{"value1", "data1"}, {"value2", "data2"}}}
    };

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

    return 0;
}

Lưu ý 1: Để điền vào bản đồ, tôi đã sử dụng danh sách trình khởi tạo (là tính năng C ++ 11 ). Điều này đôi khi có thể có ích để giữ cho các khởi tạo cố định nhỏ gọn.

Lưu ý 2: Nếu bạn muốn sửa đổi bản đồ mtrong các vòng lặp, bạn phải xóa các consttừ khóa.

Mã trên Coliru

Giải pháp đầu tiên là Sử dụng phạm vi cho vòng lặp, như:

Lưu ý: Khi range_expressionloại là std::mapthì range_declarationloại của std::pair.

for ( range_declaration : range_expression )      
  //loop_statement

Mã 1:

typedef std::map<std::string, std::map<std::string, std::string>> StringToStringMap;

StringToStringMap my_map;

for(const auto &pair1 : my_map) 
{
   // Type of pair1 is std::pair<std::string, std::map<std::string, std::string>>
   // pair1.first point to std::string (first key)
   // pair1.second point to std::map<std::string, std::string> (inner map)
   for(const auto &pair2 : pair1.second) 
   {
       // pair2.first is the second(inner) key
       // pair2.second is the value
   }
}

Giải pháp thứ hai:

Mã 2

typedef std::map<std::string, std::string> StringMap;
typedef std::map<std::string, StringMap> StringToStringMap;

StringToStringMap my_map;

for(StringToStringMap::iterator it1 = my_map.begin(); it1 != my_map.end(); it1++)
{
    // it1->first point to first key
    // it2->second point to inner map
    for(StringMap::iterator it2 = it1->second.begin(); it2 != it1->second.end(); it2++)
     {
        // it2->second point to value
        // it2->first point to second(inner) key 
     }
 }