Comment trouver si une clé donnée existe dans un C ++ std :: map

J’essaie de vérifier si une clé donnée est dans une carte et ne peut pas le faire:

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

Alors, comment puis-je imprimer ce qui est dans p?

Utilisez la map::find

 if ( m.find("f") == m.end() ) { // not found } else { // found } 

Pour vérifier si une clé particulière de la carte existe, utilisez la fonction de compte de l’une des manières suivantes:

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

La documentation de map::find dit: “Une autre fonction membre, map::count , peut être utilisée pour vérifier si une clé particulière existe.”

La documentation de map::count dit: “Comme tous les éléments d’un conteneur de carte sont uniques, la fonction ne peut renvoyer que 1 (si l’élément est trouvé) ou zéro (sinon).”

Pour récupérer une valeur de la carte via une clé que vous connaissez, utilisez map :: at :

 value = m.at(key) 

Contrairement à map :: operator [] , map::at ne créera pas de nouvelle clé dans la carte si la clé spécifiée n’existe pas.

Vous pouvez utiliser .find() :

 map::iterator i = m.find("f"); if (i == m.end()) { /* Not found */ } else { /* Found, i->first is f, i->second is ++-- */ } 
 m.find == m.end() // not found 

Si vous souhaitez utiliser d’autres API, recherchez go pour 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"; 

Je pense que vous voulez map::find . Si m.find("f") est égal à m.end() , la clé n’a pas été trouvée. Sinon, find renvoie un iterator pointant vers l’élément trouvé.

L’erreur est que p.first est un iterator, qui ne fonctionne pas pour l’insertion de stream. Changez votre dernière ligne en cout << (p.first)->first; . p est une paire d’iterators, p.first est un iterator, p.first->first est la chaîne de clé.

Une carte ne peut avoir qu’un seul élément pour une clé donnée, donc equal_range n’est pas très utile. Il est défini pour map, car il est défini pour tous les conteneurs associatifs, mais il est beaucoup plus intéressant pour le multimap.

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

Bien sûr, si vous voulez devenir plus sophistiqué, vous pouvez toujours créer une fonction qui prend également une fonction trouvée et une fonction non trouvée, quelque chose comme ceci:

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

Et l’utiliser comme ça:

  std::map 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; }); 

L'inconvénient de cela est de trouver un bon nom, "find_and_execute" est embarrassant et je ne peux rien imaginer de mieux ...

Faites attention en comparant le résultat de la recherche avec la fin comme pour la carte ‘m’, comme toutes les réponses ont été faites ci-dessus map :: iterator i = m.find (“f”);

  if (i == m.end()) { } else { } 

vous ne devez pas essayer d’effectuer une opération telle que l’impression de la clé ou de la valeur avec l’iterator i si sa valeur est égale à m.end () sinon cela entraînera une erreur de segmentation.

 map m; 

la clé de vérification existe ou non, et renvoie le nombre de résultats (0/1 dans la carte):

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

la clé de vérification existe ou non, et renvoie l’iterator:

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

Dans votre question, l’erreur provoquée par un mauvais operator<< overload car p.first est map , vous ne pouvez pas l'imprimer. essaye ça:

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

En comparant le code de std :: map :: find et std :: map :: count, je dirais que le premier peut générer des avantages en termes de performances:

 const_iterator find(const key_type& _Keyval) const { // find an element in nonmutable sequence that matches _Keyval const_iterator _Where = lower_bound(_Keyval); // Here one looks only for lower bound return (_Where == end() || _DEBUG_LT_PRED(this->_Getcomp(), _Keyval, this->_Key(_Where._Mynode())) ? end() : _Where); } size_type count(const key_type& _Keyval) const { // count all elements that match _Keyval _Paircc _Ans = equal_range(_Keyval); // Here both lower and upper bounds are to be found, which is presumably slower. size_type _Num = 0; _Distance(_Ans.first, _Ans.second, _Num); return (_Num); } 

Si vous voulez comparer une paire de cartes, vous pouvez utiliser cette méthode:

 typedef map TestMap; TestMap testMap; pair::iterator,bool> controlMapValues; controlMapValues= testMap.insert(std::pair(x,y)); if (controlMapValues.second == false ) { TestMap::iterator it; it = testMap.find(x); if (it->second == y) { cout<<"Given value is already exist in Map"< 

C'est une technique utile.

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