[C++] Come trovare se esiste una determinata chiave in una C ++ std :: map


Answers

Per verificare se esiste una determinata chiave nella mappa, utilizzare la funzione membro di count in uno dei seguenti modi:

m.count(key) > 0
m.count(key) == 1
m.count(key) != 0

La documentation per map::find dice: "Un'altra funzione membro, map::count , può essere usata per controllare solo se esiste una determinata chiave."

La map::count per map::count dice: "Poiché tutti gli elementi in un contenitore di mappe sono univoci, la funzione può restituire solo 1 (se l'elemento è trovato) o zero (altrimenti)."

Per recuperare un valore dalla mappa tramite una chiave che tu sai di esistere, usa map::at :

value = m.at(key)

A differenza di map::operator[] , map::at non creerà una nuova chiave nella mappa se la chiave specificata non esiste.

Question

Sto provando a controllare se una determinata chiave è in una mappa e in qualche modo non posso farlo:

typedef map<string,string>::iterator mi;
map<string, string> m;
m.insert(make_pair("f","++--"));
pair<mi,mi> p = m.equal_range("f");//I'm not sure if equal_range does what I want
cout << p.first;//I'm getting error here

quindi, come posso stampare ciò che è in p?




map <int , char>::iterator itr;
    for(itr = MyMap.begin() ; itr!= MyMap.end() ; itr++)
    {
        if (itr->second == 'c')
        {
            cout<<itr->first<<endl;
        }
    }



map<string, string> m;

la chiave di controllo esiste o no, e restituisce il numero di occorrenze (0/1 nella mappa):

int num = m.count("f");  
if (num>0) {    
    //found   
} else {  
    // not found  
}

la chiave di controllo esiste o no e restituisce l'iteratore:

map<string,string>::iterator mi = m.find("f");  
if(mi != m.end()) {  
    //found  
    //do something to mi.  
} else {  
    // not found  
}  

nella tua domanda, l'errore causato da un operator<< brutto operator<< sovraccarico, perché p.first è map<string, string> , non puoi stamparlo. prova questo:

if(p.first != p.second) {
    cout << p.first->first << " " << p.first->second << endl;
}



template <typename T, typename Key>
bool key_exists(const T& container, const Key& key)
{
    return (container.find(key) != std::end(container));
}

Ovviamente, se volessi diventare più esperto, potresti sempre definire una funzione che ha anche una funzione trovata e una funzione non trovata, qualcosa del genere:

template <typename T, typename Key, typename FoundFunction, typename NotFoundFunction>
void find_and_execute(const T& container, const Key& key, FoundFunction found_function, NotFoundFunction not_found_function)
{
    auto& it = container.find(key);
    if (it != std::end(container))
    {
        found_function(key, it->second);
    }
    else
    {
        not_found_function(key);
    }
}

E usalo in questo modo:

    std::map<int, int> some_map;
    find_and_execute(some_map, 1,
        [](int key, int value){ std::cout << "key " << key << " found, value: " << value << std::endl; },
        [](int key){ std::cout << "key " << key << " not found" << std::endl; });

Il rovescio della medaglia di questo è un buon nome, "find_and_execute" è imbarazzante e non riesco a trovare niente di meglio in cima alla mia testa ...




m.find == m.end() // not found 

Se si desidera utilizzare altre API, quindi cercare m.count(c)>0

 if (m.count("f")>0)
      cout << " is an element of m.\n";
    else 
      cout << " is not an element of m.\n";