Déterminer si la carte contient une valeur pour une clé?

Quelle est la meilleure façon de déterminer si une carte STL contient une valeur pour une clé donnée?

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

}

En examinant cela dans un débogueur, il semble que ce ne itersoient que des données poubelles.

Si je commente cette ligne:

Bar b2 = m[2]

Les spectacles de débogage qui b2est {i = 0}. (Je suppose que cela signifie que l'utilisation d'un index non défini retournera une structure avec toutes les valeurs vides / non initialisées?)

Aucune de ces méthodes n'est si géniale. Ce que j'aimerais vraiment, c'est une interface comme celle-ci:

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

Existe-t-il quelque chose dans ce sens?

Existe-t-il quelque chose dans ce sens?

Non. Avec la classe de carte stl, vous utilisez ::find()pour rechercher la carte et comparer l'itérateur retourné àstd::map::end()

alors

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

Évidemment, vous pouvez écrire votre propre getValue()routine si vous le souhaitez (également en C ++, il n'y a aucune raison de l'utiliser out), mais je soupçonnerais qu'une fois que vous maîtriserez l'utilisation, std::map::find()vous ne voudrez pas perdre votre temps.

De plus, votre code est légèrement faux:

m.find('2');recherchera sur la carte une valeur clé qui est '2'. IIRC le compilateur C ++ convertira implicitement «2» en un int, ce qui entraîne la valeur numérique du code ASCII pour «2» qui n'est pas ce que vous voulez.

Étant donné que votre type de clé dans cet exemple est que intvous souhaitez rechercher comme ceci:m.find(2);

Tant que la carte n'est pas une carte multiple, l'un des moyens les plus élégants serait d'utiliser la méthode de comptage

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

Le compte serait de 1 si l'élément est bien présent sur la carte.

Il existe déjà avec find seulement pas dans cette syntaxe exacte.

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

Si vous souhaitez accéder à la valeur si elle existe, vous pouvez faire:

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

Avec C ++ 0x et auto, la syntaxe est plus simple:

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

Je vous recommande de vous y habituer plutôt que d'essayer de trouver un nouveau mécanisme pour le simplifier. Vous pourriez être en mesure de réduire un peu de code, mais considérez le coût de le faire. Vous avez maintenant introduit une nouvelle fonction que les personnes familiarisées avec C ++ ne pourront pas reconnaître.

Si vous souhaitez malgré tout implémenter cela malgré ces avertissements, alors:

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

Je viens de remarquer qu'avec C ++ 20 , nous aurons

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

Cela retournera vrai si map contient un élément avec clé key.

amap.findrevient amap::endquand il ne trouve pas ce que vous cherchez - vous êtes censé vérifier cela.

Vérifiez la valeur de retour de findcontre end.

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

Vous pouvez créer votre fonction getValue avec le code suivant:

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

Pour résumer brièvement certaines des autres réponses:

Si vous n'utilisez pas encore C ++ 20, vous pouvez écrire votre propre mapContainsKeyfonction:

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

Si vous souhaitez éviter de nombreuses surcharges pour mapvs unordered_mapet différents types de clés et de valeurs, vous pouvez en faire une templatefonction.

Si vous utilisez C++ 20ou plus tard, il y aura une containsfonction intégrée:

std::map<int, int> myMap;

// do stuff with myMap here

int key = 123;

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

Si vous souhaitez déterminer si une clé se trouve dans la carte ou non, vous pouvez utiliser la fonction membre find () ou count () de la carte. La fonction find qui est utilisée ici dans l'exemple renvoie sinon l'itérateur à element ou map :: end. En cas de comptage, le comptage renvoie 1 s'il est trouvé, sinon il renvoie zéro (ou autre).

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 peut être utilisé pour une solution appropriée. La solution suivante n'est pas une meilleure option mais peut être utile dans quelques cas où l'utilisateur attribue une valeur par défaut comme 0 ou NULL à l'initialisation et veut vérifier si la valeur a été modifiée.

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