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

Estoy tratando de verificar si una clave dada está en un mapa y de alguna manera no puedo hacerlo:

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

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

Utilizar map::find

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

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

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

La documentación de map::finddice: "Otra función miembro map::count, puede usarse para verificar si existe una clave en particular".

La documentación de map::countdice: "Debido a que todos los elementos en un contenedor de mapas 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 sabe que existe, use map :: at :

value = m.at(key)

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

C ++ 20 nos da std::map::containspara hacer eso.

#include <iostream>
#include <string>
#include <map>

int main()
{
    std::map<int, std::string> example = {{1, "One"}, {2, "Two"}, 
                                     {3, "Three"}, {42, "Don\'t Panic!!!"}};

    if(example.contains(42)) {
        std::cout << "Found\n";
    } else {
        std::cout << "Not found\n";
    }
}

Puedes usar .find():

map<string,string>::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.firstes un iterador, que no funciona para la inserción de secuencias. Cambia tu última línea a cout << (p.first)->first;. pes un par de iteradores, p.firstes un iterador, p.first->firstes la cadena clave.

Un mapa solo puede tener un elemento para una clave determinada, por equal_rangelo que no es muy útil. Está definido para el mapa, porque está definido para todos los contenedores asociativos, pero es mucho más interesante para los mapas múltiples.

C++17simplificado esto un poco más con un If statement with initializer. De esta manera puedes tener tu pastel y comértelo también.

if ( auto it{ m.find( "key" ) }; it != std::end( m ) ) 
{
    // Use `structured binding` to get the key
    // and value.
    auto[ key, value ] { *it };

    // Grab either the key or value stored in the pair.
    // The key is stored in the 'first' variable and
    // the 'value' is stored in the second.
    auto mkey{ it->first };
    auto mvalue{ it->second };

    // That or just grab the entire pair pointed
    // to by the iterator.
    auto pair{ *it };
} 
else 
{
   // Key was not found..
}

map<string, string> m;

la clave de verificación existe o no, y el número de retorno ocurre (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 devuelve el iterador:

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

en su pregunta, el error causado por una mala operator<<sobrecarga, porque p.firstes map<string, string>, no puede imprimirlo. prueba esto:

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

Por supuesto, si desea ser más elegante, siempre puede crear una función que también tome una función encontrada y una función no encontrada, algo como esto:

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

Y úsalo así:

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

La desventaja de esto es que viene con un buen nombre, "find_and_execute" es incómodo y no se me ocurre nada mejor en la parte superior de mi cabeza ...

Tenga cuidado al comparar el resultado de búsqueda con el final, como para el mapa 'm', ya que todas las respuestas se han hecho sobre 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 () de lo contrario, provocará un error de segmentación.

Comparando el código de std :: map :: find y std :: map :: count, diría que el primero puede proporcionar 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 presumably slower.
    size_type _Num = 0;
    _Distance(_Ans.first, _Ans.second, _Num);
    return (_Num);
    }

Sé que esta pregunta ya tiene algunas buenas respuestas, pero creo que vale la pena compartir mi solución.

Funciona para ambos std::mapy std::vector<std::pair<T, U>>está disponible en C ++ 11.

template <typename ForwardIterator, typename Key>
bool contains_key(ForwardIterator first, ForwardIterator last, Key const key) {
    using ValueType = typename std::iterator_traits<ForwardIterator>::value_type;

    auto search_result = std::find_if(
        first, last,
        [&key](ValueType const& item) {
            return item.first == key;
        }
    );

    if (search_result == last) {
        return false;
    } else {
        return true;
    }
}

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

typedef map<double, double> TestMap;
TestMap testMap;
pair<map<double,double>::iterator,bool> controlMapValues;

controlMapValues= testMap.insert(std::pair<double,double>(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"<<endl;
    }
}

Esta es una técnica útil.

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