Cómo encontrar si una clave dada existe en un C ++ std :: map

Estoy tratando de verificar si una clave determinada está en un mapa y algo no puede hacerlo:

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 

Entonces, ¿cómo puedo imprimir lo que está en p?

Usar map::find

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

Para verificar si existe una clave particular en el mapa, use la función de miembro de count de una de las siguientes maneras:

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

La documentación para map::find dice: “Se puede usar otra función miembro, map::count , para verificar si existe una clave en particular”.

La documentación para map::count dice: “Como todos los elementos en un contenedor de mapa son únicos, la función solo puede devolver 1 (si se encuentra el elemento) o cero (de lo contrario)”.

Para recuperar un valor del mapa a través de una clave que sabes que existe, utiliza map :: at :

 value = m.at(key) 

A diferencia de map :: operator [] , map::at no creará una nueva clave en el mapa si la clave especificada no existe.

Puedes usar .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 desea utilizar otra API, busque ir a 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"; 

Creo que quieres map::find . Si m.find("f") es igual a m.end() , entonces no se encontró la clave. De lo contrario, find devuelve un iterador que apunta al elemento encontrado.

El error se debe a que p.first es un iterador, que no funciona para la inserción de secuencias. Cambie su última línea para cout << (p.first)->first; . p es un par de iteradores, p.first es un iterador, p.first->first es la cadena clave.

Un mapa solo puede tener un elemento para una clave determinada, por lo que equal_range no es muy útil. Se define para el mapa, porque está definido para todos los contenedores asociativos, pero es mucho más interesante para multimap.

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

Por supuesto, si quieres ser más elegante, siempre puedes diseñar una función que también tenga una función encontrada y una función no encontrada, algo como esto:

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

Y úsalo así:

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

La desventaja de esto es encontrar un buen nombre, "find_and_execute" es incómodo y no puedo encontrar nada mejor en la cabeza ...

Tenga cuidado al comparar el resultado de búsqueda con el final como para el mapa ‘m’, ya que todas las respuestas lo han hecho anteriormente map :: iterator i = m.find (“f”);

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

no debe intentar realizar ninguna operación, como imprimir la clave o el valor con el iterador i, si es igual a m.end () sino que generará un error de segmentación.

 map m; 

la clave de verificación existe o no, y se produce el número de devolución (0/1 en el mapa):

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

la clave de verificación existe o no, y el iterador de retorno:

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

en su pregunta, el error causado por la operator<< sobrecarga del operator<< incorrecto, porque p.first es map , no puede imprimirlo. prueba esto:

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

Comparando el código de std :: map :: find y std :: map :: count, diría que el primero puede dar alguna ventaja de rendimiento:

 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 presumbly slower. size_type _Num = 0; _Distance(_Ans.first, _Ans.second, _Num); return (_Num); } 

Si quiere comparar un par de mapas, puede usar este método:

 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"< 

Esta es una técnica útil.

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