如何将map::find()方法用于嵌套映射

Question

我有一个map<int, map<int,int>> mymap;

如何将find()方法用于像这样的嵌套map？

如果我有map<int,int> mymap, mymap.find(key)，它会给出一个结果。但是对于多于一个密钥的嵌套map呢？

Answer 1

还要注意有std::map::at。

如果不存在匹配的密钥，它会抛出std::out_of_range，但在您的情况下使用很简单。

auto value = mymap.at(key1).at(key2);

如果你不确定钥匙是否存在，你可以抓住这个例外，或者按照雷米的回答。

Answer 2

mymap.find()将搜索第一个关键字，并向包含该关键字的关联值的std::pair返回迭代器，该值是std::map。

然后，该std::map上的find()将搜索第二个关键字，向包含其相关值的std::pair返回迭代器，该值是int。

例如：

map<int, map<int,int>> mymap;
auto it1 = mymap.find(key1);
if (it1 != mymap.end()) {
auto it2 = it1->second.find(key2);
if (it2 != it1->second.end()) {
// use it2->second as needed...
}
}

Answer 3

之后

auto entry = mymap.find(key);

您发现entry是包含(const！(键和值的std::pair的迭代器，在您的情况下，后者是另一个映射，因此：

auto subEntry = entry->second.find(subKey)

(当然，提供entry != mymap.end()！(

Answer 4

提供一个处理此类情况的工具是一种很好的做法。

因此，Remy提供的解决方案应该采用帮助函数或通用模板的形式：

template<typename T, typename Key>
auto optional_at(T& x, Key&& key)
-> std::optional<typename T::mapped_type>
{
auto it = x.find(std::forward<Key>(key));
if (it == x.end()) 
return {};
return it->second;
}
template<typename T, typename Key, typename ...Keys>
auto optional_at(T& x, Key&& key, Keys&&...keys)
-> decltype(optional_at(x[key], std::forward<Keys>(keys)...))
{
auto it = x.find(std::forward<Key>(key));
if (it != x.end()) 
return optional_at(it->second, std::forward<Keys>(keys)...);
return {};
}
//---------------------
int main()
{
std::map<int, std::map<int, std::string>> m{
{1, {{1, "one-one"}}},
{2, {{1, "two-one"}, {2, "two-two"}}}
};

...
print(std::cout, optional_at(m, 1, 2)) << 'n';
print(std::cout, optional_at(m, 2, 1)) << 'n';
print(std::cout, optional_at(m, 2, 2)) << 'n';
...
return 0;
}

现场演示

然后，当使用这个时，意图是明确和简单的。