Simplest method to check whether unordered_map of unordered_maps contains key

You might also use count ( )

which will return 0 if key not exist

template<class M>
bool contains(M const&){return true;}
template<class M, class K, class...Ks>
bool contains(M const&m, K const&k, Ks const&...ks){
  auto it=m.find(k);
  if (it==m.end()) return false;
  return contains(it->second, ks...);

will work for every single-valued associative container.

contains(my_map, k1, k2) is true if there is an element k1 which contains k2.

In C++20, you can use the contains method (added to all associative containers if I am not mistaken):

if (my_map.contains(k1) && my_map[k1].contains(k2))
    // do something with my_map[k1][k2]

If your intention is to test for the existence of the key, I would not use


because operator[] will default construct a new value for that key if it does not already exist.

Rather I would prefer to use std::unordered_map::find. So if you are certain the first key exists, but not the second you could do

if (my_map[k1].find(k2) != my_map[k1].end())
    // k2 exists in unordered_map for key k1

If you would like to make a function that checks for the existence of both keys, then you could write something like

/// \brief Determines a nested map contains two keys (the outer containing the inner)
/// \param[in] data Outer-most map
/// \param[in] a    Key used to find the inner map
/// \param[in] b    Key used to find the value within the inner map
/// \return True if both keys exist, false otherwise
template <class key_t, class value_t>
bool nested_key_exists(std::unordered_map<key_t, std::unordered_map<key_t, value_t>> const& data, key_t const a, key_t const b)
    auto itInner = data.find(a);
    if (itInner != data.end())
        return itInner->second.find(b) != itInner->second.end();
    return false;