Determinare se la mappa contiene un valore per una chiave?

Qual è il modo migliore per determinare se una mappa STL contiene un valore per una determinata chiave?

#include <map>

using namespace std;

struct Bar
{
    int i;
};

int main()
{
    map<int, Bar> m;
    Bar b = {0};
    Bar b1 = {1};

    m[0] = b;
    m[1] = b1;

    //Bar b2 = m[2];
    map<int, Bar>::iterator iter = m.find(2);
    Bar b3 = iter->second;

}

Esaminandolo in un debugger, sembra che itersiano solo dati inutili.

Se decomprimere questa riga:

Bar b2 = m[2]

Il debugger mostra che lo b2è {i = 0}. (Suppongo significhi che l'utilizzo di un indice indefinito restituirà una struttura con tutti i valori vuoti / non inizializzati?)

Nessuno di questi metodi è così eccezionale. Quello che mi piacerebbe davvero è un'interfaccia come questa:

bool getValue(int key, Bar& out)
{
    if (map contains value for key)
    {
        out = map[key];
        return true;
    }
    return false;
}

Esiste qualcosa di simile?

Esiste qualcosa di simile?

No. Con la classe stl map, si utilizza ::find()per cercare la mappa e confrontare l'iteratore restituito constd::map::end()

così

map<int,Bar>::iterator it = m.find('2');
Bar b3;
if(it != m.end())
{
   //element found;
   b3 = it->second;
}

Ovviamente puoi scrivere la tua getValue()routine se vuoi (anche in C ++, non c'è motivo di usarlo out), ma sospetterei che una volta che avrai imparato a usare std::map::find()non vorrai perdere tempo.

Anche il tuo codice è leggermente sbagliato:

m.find('2');cercherà un valore chiave nella mappa '2'. IIRC il compilatore C ++ convertirà implicitamente '2' in un int, il che si tradurrà nel valore numerico per il codice ASCII per '2' che non è quello che vuoi.

Dato che il tuo tipo di chiave in questo esempio è intche vuoi cercare in questo modo:m.find(2);

Finché la mappa non è una multimappa, uno dei modi più eleganti sarebbe usare il metodo di conteggio

if (m.count(key))
    // key exists

Il conteggio sarebbe 1 se l'elemento è effettivamente presente nella mappa.

Esiste già con find, non solo in quella sintassi esatta.

if (m.find(2) == m.end() )
{
    // key 2 doesn't exist
}

Se vuoi accedere al valore se esiste, puoi fare:

map<int, Bar>::iterator iter = m.find(2);
if (iter != m.end() )
{
    // key 2 exists, do something with iter->second (the value)
}

Con C ++ 0x e auto, la sintassi è più semplice:

auto iter = m.find(2);
if (iter != m.end() )
{
    // key 2 exists, do something with iter->second (the value)
}

Ti consiglio di abituarti piuttosto che provare a trovare un nuovo meccanismo per semplificarlo. Potresti riuscire a ridurre un po 'di codice, ma considera il costo per farlo. Ora hai introdotto una nuova funzione che le persone che hanno familiarità con C ++ non saranno in grado di riconoscere.

Se vuoi implementarlo comunque nonostante questi avvertimenti, allora:

template <class Key, class Value, class Comparator, class Alloc>
bool getValue(const std::map<Key, Value, Comparator, Alloc>& my_map, int key, Value& out)
{
    typename std::map<Key, Value, Comparator, Alloc>::const_iterator it = my_map.find(key);
    if (it != my_map.end() )
    {
        out = it->second;
        return true;
    }
    return false;
}

Ho appena notato che con C ++ 20 avremo

bool std::map::contains( const Key& key ) const;

Ciò tornerà vero se map contiene un elemento con chiave key.

amap.findritorna amap::endquando non trova quello che stai cercando - dovresti verificarlo.

Controllare il valore di ritorno di findcontro end.

map<int, Bar>::iterator it = m.find('2');
if ( m.end() != it ) { 
  // contains
  ...
}

Puoi creare la tua funzione getValue con il seguente codice:

bool getValue(const std::map<int, Bar>& input, int key, Bar& out)
{
   std::map<int, Bar>::iterator foundIter = input.find(key);
   if (foundIter != input.end())
   {
      out = foundIter->second;
      return true;
   }
   return false;
}

Riassumendo sinteticamente alcune delle altre risposte:

Se non stai ancora utilizzando C ++ 20, puoi scrivere la tua mapContainsKeyfunzione:

bool mapContainsKey(std::map<int, int>& map, int key)
{
  if (map.find(key) == map.end()) return false;
  return true;
}

Se desideri evitare molti sovraccarichi per mapvs unordered_mape tipi di chiave e valore diversi, puoi renderlo una templatefunzione.

Se stai usando C++ 20o più tardi, ci sarà una containsfunzione integrata:

std::map<int, int> myMap;

// do stuff with myMap here

int key = 123;

if (myMap.contains(key))
{
  // stuff here
}

Se vuoi determinare se una chiave è presente nella mappa o meno, puoi usare la funzione membro find () o count () della mappa. La funzione find che viene usata qui nell'esempio restituisce l'iteratore in element o map :: end altrimenti. In caso di conteggio il conteggio restituisce 1 se trovato, altrimenti restituisce zero (o in altro modo).

if(phone.count(key))
{ //key found
}
else
{//key not found
}

for(int i=0;i<v.size();i++){
    phoneMap::iterator itr=phone.find(v[i]);//I have used a vector in this example to check through map you cal receive a value using at() e.g: map.at(key);
    if(itr!=phone.end())
        cout<<v[i]<<"="<<itr->second<<endl;
    else
        cout<<"Not found"<<endl;
}

Boost multindex può essere utilizzato per una soluzione adeguata. La seguente soluzione non è un'opzione ottimale ma potrebbe essere utile in alcuni casi in cui l'utente sta assegnando un valore predefinito come 0 o NULL all'inizializzazione e desidera verificare se il valore è stato modificato.

Ex.
< int , string >
< string , int > 
< string , string > 

consider < string , string >
mymap["1st"]="first";
mymap["second"]="";
for (std::map<string,string>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
{
       if ( it->second =="" ) 
            continue;
}