Méthode la plus simple pour vérifier si unordered_map de unordered_maps contient la clé

Je suis en utilisant un unordered_map de unordered_maps, tel que je peut faire référence à un élément à l'aide de la "multi-clé" syntaxe:

my_map[k1][k2].

Est-il un moyen pratique d'utiliser le même "multi-touche" syntaxe pour vérifier si un élément existe avant d'essayer de l'ouvrir? Si non, quel est le moyen le plus simple?

OriginalL'auteur user997112 | 2015-12-29

  1. 29

    Si votre intention est de tester l'existence de la clé, je ne voudrais pas utiliser

    my_map[k1][k2]

    parce que operator[] sera, par défaut, la construction d'une nouvelle valeur de cette clé si elle n'existe pas déjà.

    Plutôt je préfère utiliser std::unordered_map::find. Donc, si vous êtes certains de la première clé existe, mais pas la seconde que vous pourriez faire

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

    Si vous souhaitez faire une fonction qui vérifie l'existence de les deux clés, alors vous pourriez écrire quelque chose comme

    //------------------------------------------------------------------------------
///\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;
}
    Et si vous n'êtes pas certains que k1 existe, vous aurez envie d'utiliser find deux fois - une fois pour vérifier k1 et une fois pour vérifier k2.
    Je pense que c'est ce dont j'ai besoin.
    Dans ce cas, vous pouvez utiliser le nested_key_exists fonction dans la partie inférieure de la réponse. Il sera de retour true si les deux clés existent, false autrement.
    Il n'est pas clair si la valeur my_map[k1] serait mis en cache deux recherches pourrait être cher
    Bon point, si c'est un sujet de préoccupation à l'intérieur de la carte (extrait de my_map[k1] peut être stocké dans une variable temporaire pour éviter de faire de la recherche à deux reprises.

    OriginalL'auteur 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...);
}

    de travail pour chaque valeur unique conteneur associatif.

    contains(my_map, k1, k2) est vrai si il y a un élément k1 qui contient k2.

    OriginalL'auteur Yakk - Adam Nevraumont

  3. 1

    Quelque chose comme cela? (pour la mutable cas)

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

    appelé de la sorte:

    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
}

    ... ou il y a le plus de python comme...

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

    OriginalL'auteur Richard Hodges

  4. 0

    Je ne crois pas qu'il existe un multi-syntaxe des clés à vérifier, mais la façon la plus simple serait d'utiliser le find méthode. Vous pouvez écrire une fonction simple de l'appliquer à un unordered_map de unordered_maps

    référence

    OriginalL'auteur Aiden Deom

  5. 0

    Vous pouvez également utiliser la fonction count (http://www.cplusplus.com/reference/unordered_map/unordered_map/count/ )

    qui renvoie 0 si la clé n'existe pas

    OriginalL'auteur Hui Liu