Einfachste Methode um zu überprüfen, ob unordered_map von unordered_maps enthält die wichtigsten

Bin ich mit einer unordered_map von unordered_maps, so dass ich den Verweis auf ein element mit Hilfe der "multi-key" - syntax:

my_map[k1][k2].

Ist es ein bequemer Weg, um die gleiche "multi-key" - syntax zu überprüfen, ob ein element existiert, bevor Sie versuchen, darauf zuzugreifen? Wenn nicht, was ist der einfachste Weg?

InformationsquelleAutor der Frage user997112 | 2015-12-29

  1. 27

    Wenn Ihre Absicht ist, um test für das Vorhandensein des Schlüssels, würde ich nicht verwenden,

    my_map[k1][k2]

    weil operator[] wird standardmäßig konstruieren Sie einen neuen Wert für diesen Schlüssel (wenn es nicht bereits vorhanden ist.

    Eher würde ich es vorziehen, zu verwenden std::unordered_map::find. Also, wenn Sie sicher sind, dass der erste Schlüssel vorhanden ist, aber nicht die zweite, die Sie tun könnten

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

    Wenn Sie möchten, um eine Funktion, die überprüft das Vorhandensein von beide Schlüssel, dann könnte man etwas schreiben wie

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

    InformationsquelleAutor der Antwort CoryKramer

  2. 3
    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...);
}

    wird für jedes einwertige assoziative container.

    contains(my_map, k1, k2) ist wahr, wenn es ein element k1 enthält k2.

    InformationsquelleAutor der Antwort Yakk - Adam Nevraumont

  3. 1

    So etwas? (für die veränderliche Fall)

    using inner_map = std::map<key_type, value_type>;
using outer_map = std::map<key_type, inner_map>

boost::optional<value_type&> 
element_for_keys(outer_map& map, const key_type& k1, const key_type& k2)
{
  auto it_outer = map.find(k1);
  if (it_outer = map.end())
    return {};
  auto &map2 = it_outer->second;
  auto it_inner = map2.find(k2);
  if (it_inner == map2.end())
    return {};

  return { it_inner->second };
}

    genannt, etwa so:

    auto op_value = element_for_keys(my_map, kv1, kv2);
if (op_value) {
  //use op_value.value()
}
else {
  //handle case where it does not exist
}

    ... oder es gibt die mehr python-wie Weg...

    try {
  auto& v = my_map.at(k1).at(k2);
  //use v
}
catch(const std::out_of_range & e) {
  //didn't find it
}

    InformationsquelleAutor der Antwort Richard Hodges

  4. 0

    Glaube ich nicht, es ist ein multi-key-syntax zu überprüfen, aber der einfachste Weg wäre, um die find Methode. Sie schreiben, könnte eine einfache Funktion anwenden, um eine unordered_map von unordered_maps

    Referenz

    InformationsquelleAutor der Antwort Aiden Deom

  5. 0

    Könnte man auch verwenden, count (http://www.cplusplus.com/reference/unordered_map/unordered_map/count/ )

    die 0 zurück, wenn key nicht vorhanden

    InformationsquelleAutor der Antwort Hui Liu

Schreibe einen Kommentar