C++ 如何循环通过C++；地图？ ？我的地图定义为： std::map< std::string, std::map<std::string, std::string> >

如何循环遍历此映射并访问各种值？

您可以使用迭代器

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

typedef std:：map:：iterator it_type；
for（it_type iterator=m.begin（）；iterator！=m.end（）；iterator++）{
//迭代器->第一个=键
//迭代器->秒=值
//如果还希望迭代第二个贴图，请重复此操作。
}

for（std:：map:：iterator outer_iter=map.begin（）；outer_iter！=map.end（）；++outer_iter）{
对于（std:：map:：iterator internal_iter=outer_iter->second.begin（）；internal_iter！=outer_iter->second.end（）；++inner_iter）{
std:：cout second.begin（）；internal_iter！=outer_iter->second.end（）；++internal_iter）{
std:：cout second执行以下操作：

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

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

typedef std:：map InnerMap；
typedef std：：映射OuterMap；
外标毫米；
…//设置初始值
对于（OuterMap:：迭代器i=mm.begin（）；i！=mm.end（）；++i）{
InnerMap&im=i->second；
对于（InnerMap:：iterator ii=im.begin（）；ii！=im.end（）；++ii）{
std:：cout旧问题，但剩余的答案在C++11中已经过时-您可以使用，只需执行以下操作：

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

当映射为常量时，使用
std:：map：：const_迭代器
。
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;

对于C++17（或更高版本），您可以使用“结构化绑定”功能，该功能允许您使用单个元组/对定义多个具有不同名称的变量。例如：

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

for（const auto&[name，description]：行星描述）{
std:：cout正如中提到的einpoklum，因为您也可以使用。我想通过提供一个完整的解决方案，以舒适的方式迭代地图来扩展这一点：

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

intmain（）{
映射{
{“name1”、{{“value1”、“data1”}、{“value2”、“data2”}，
{“name2”{{“value1”、“data1”}、{“value2”、“data2”}，
{“name3”、{{“value1”、“data1”}、{“value2”、“data2”}
};
用于（常数自动和[k1，v1]：m）
对于（常数自动和[k2，v2]：v1）
std:：cout第一种解决方案是基于使用范围的for循环，如：

注意：当
range\u表达式
的类型为
std:：map
时，
range\u声明
的类型为
std:：pair

for ( range_declaration : range_expression )      
  //loop_statement

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

typedef std:：map StringToStringMap；
StringToStringMap my_map；
用于（const auto&pair1：我的地图）
{
//pair1的类型是std:：pair
//pair1.std:：string的第一个点（第一个键）
//pair1.2点到std:：map（内部映射）
用于（常数自动和pair2:pair1.秒）
{
//pair2.first是第二个（内部）键
//pair2.second是值
}
}

第二个解决方案：

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

typedef std:：map StringMap；
typedef std:：映射字符串到字符串映射；
StringToStringMap my_map；
for（StringToStringMap:：迭代器it1=my_map.begin（）；it1！=my_map.end（）；it1++）
{
//it1->第一个点到第一个键
//it2->第二点至内部地图
对于（StringMap:：迭代器it2=it1->second.begin（）；it2！=it1->second.end（）；it2++）
{
//it2->第二个点对值
//it2->第一个点到第二个（内部）键
}
}
除非他打算修改映射，否则使用const_迭代器会更好。使用++迭代器比迭代器++更有效，因为它在递增时避免了不必要的复制。使用auto大大简化了C++11的循环：
for（auto iterator=m.begin（）；iterator！=m.end（）；iterator++）
这对于c++11来说已经过时了。只需使用（auto-iter:mymap）对于c++11，您应该使用（auto&iter:mymap）为了避免潜在的复制。在第二种情况下，它应该是++ii而不是++i:）我认为“/n”应该是endWell中的“\n”，我会在以后使用定义来取消它们的定义，但是这对于C++98:）+1是一个好方法，你应该使用auto&，或者如果你不修改映射，甚至是const auto&。此外，更喜欢非成员的begin（）和end（），例如（const auto&iter=begin（map）；…）。或者更简单一点：for（const auto&element:map）是保持答案相关性的道具——我只希望它能更接近顶部。也许将其编辑为可接受的答案是合适的？（这是我们在TeX.SX上所做的，但不同的文化也是如此。）简单地问一个问题，在
auto
之后编写
const
与您的决定是否有任何关联？这纯粹是美学上的吗？@Parham const在指定类型之前或之后是一个偏好问题，但我选择将其保留在右侧，因为在使用指针的情况下（例如使用
int-const*x
和
int-const*x
都可以写成
int-const*const*x
，这比
const-int*const*x
更清楚。但是它只是从左到右解析，所以效果是一样的。请看这个问题的答案：&在auto-const&ent2中是什么意思？@TannerSummers因为按值访问会增加复制每个元素的低效性；此外，如果要修改内容，则需要通过引用（或指针）访问元素而不是按价值。你知道，有时把代码隐藏在右边距后不是一个好习惯。我知道这样更安全，但我完全模糊了代码的视觉。Go
auto
bro，否则使用vim的人会去KO。这个答案与什么不同？除了它到处复制的事实。这太漂亮了ED投票表决尽管C++ 17还没有“那里”，但是，他们通过使编写更干净和安全的代码更容易恢复C++。
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;
}

for ( range_declaration : range_expression )      
  //loop_statement

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

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