¿Determinar si map contiene un valor para una clave?

Mientras el mapa no sea un multimap, una de las formas más elegantes sería usar el método de conteo

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

El recuento sería 1 si el elemento está efectivamente presente en el mapa.

Ya existe con find solo que no en esa sintaxis exacta.

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

Si desea acceder al valor si existe, puede hacer:

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 y auto, la sintaxis es más simple:

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

Le recomiendo que se acostumbre a él en lugar de tratar de llegar a un nuevo mecanismo para simplificarlo. Es posible que pueda reducir un poco el código, pero considere el costo de hacerlo. Ahora ha introducido una nueva función que las personas familiarizadas con C++ no podrán reconocer.

Si desea implementar esto de todos modos a pesar de estas advertencias, entonces:

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

amap.find devuelve amap::end cuando no encuentra lo que está buscando supposed se supone que debe verificar eso.

Compruebe el valor devuelto de find frente a end.

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

Acabo de notar que con C++20, tendremos

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

Que devolverá true si map contiene un elemento con clave key.

Puede crear su función getValue con el siguiente código:

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

Si desea determinar si hay una clave en map o no, puede usar la función miembro find() o count() de map. La función find que se usa aquí en el ejemplo devuelve el iterador a element o map:: end de lo contrario. En el caso de count el count devuelve 1 si se encuentra, de lo contrario devuelve cero(o de lo contrario).

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 se puede utilizar para la solución adecuada. La siguiente solución no es la mejor opción, pero puede ser útil en algunos casos en los que el usuario asigna un valor predeterminado como 0 o NULL en la inicialización y desea verificar si el valor se ha modificado.

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