metodo semplice per controllare se unordered_map di unordered_maps contiene la chiave

Question

Se si utilizza un'unordered_map di unordered_maps, tale che posso riferimento a un elemento utilizzando la sintassi "multi tasto":

my_map[k1][k2].

C'è un modo conveniente per utilizzare la stessa sintassi "multi-tasto" per verificare se un elemento esiste prima di tentare di accedervi? In caso contrario, qual è il modo più semplice?

Answer 1

Se la vostra intenzione è quella di verificare l'esistenza della chiave, non vorrei usare

my_map[k1][k2] 

perché operator[] sarà di default costruire un nuovo valore per quella chiave, se non esiste già.

Piuttosto preferirei usare std::unordered_map::find. Quindi, se si è certi esiste la prima chiave, ma non la seconda si poteva fare

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

Se volete fare una funzione che verifica l'esistenza di entrambi i tasti, allora si potrebbe scrivere qualcosa come

Answer 2

Non credo ci sia una sintassi multi-tasto da verificare, ma il modo più semplice sarebbe utilizzare il metodo find. Si potrebbe scrivere una funzione semplice da applicare ad una unordered_map di unordered_map s

reference

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

lavorerà per ogni container valore singolo associativo.

contains(my_map, k1, k2) è vero se è presente un elemento k1 che contiene k2.

Answer 4

Qualcosa di simile? (Per il caso mutabile)

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

chiamati in questo modo:

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 
} 

... o c'è il modo più python-like ...

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