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

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

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

alors comment imprimer ce qui est en p?

Utilisation map::find

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

Pour vérifier s'il existe une clé particulière dans la carte, utilisez la countfonction membre de l'une des manières suivantes:

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

La documentation de map::finddit: "Une autre fonction membre,, map::countpeut être utilisée pour vérifier simplement si une clé particulière existe."

La documentation de map::countdit: "Parce que 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 savez exister, 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.

C ++ 20 nous permet std::map::containsde le faire.

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

Vous pouvez utiliser .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 vous souhaitez utiliser une autre API, recherchez go for 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 tu veux map::find. Si m.find("f")est égal à m.end(), la clé est introuvable. Sinon, find renvoie un itérateur pointant sur l'élément trouvé.

L'erreur est due au fait qu'il p.firsts'agit d'un itérateur, qui ne fonctionne pas pour l'insertion de flux. Modifiez votre dernière ligne en cout << (p.first)->first;. pest une paire d'itérateurs, p.firstest un itérateur, p.first->firstest la chaîne de clé.

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

C++17simplifié un peu plus avec un If statement with initializer. De cette façon, vous pouvez avoir votre gâteau et le manger aussi.

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 clé de contrôle existe ou non, et le nombre de retours se produit (0/1 sur la carte):

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

vérifier que la clé existe ou non, et retourner l'itérateur:

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

dans votre question, l'erreur causée par une mauvaise operator<<surcharge, car p.firstest map<string, string>, vous ne pouvez pas l' imprimer. essaye ça:

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

Bien sûr, si vous vouliez devenir plus amateur, vous pouvez toujours créer un modèle pour une fonction qui a également pris une fonction trouvée et une fonction non trouvée, quelque chose comme ceci:

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

Et utilisez-le comme ceci:

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

L'inconvénient est de trouver un bon nom, "find_and_execute" est maladroit et je ne peux rien trouver de mieux du haut de ma tête ...

Soyez prudent en comparant le résultat de la recherche avec la fin comme pour la carte 'm' comme toutes les réponses l'ont fait 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'itérateur i si son égal à m.end () sinon cela entraînera un défaut de segmentation.

En comparant le code de std :: map :: find et std :: map :: count, je dirais que le premier peut donner un avantage 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);
    }

Je sais que cette question a déjà de bonnes réponses, mais je pense que ma solution mérite d'être partagée.

Il fonctionne pour les deux std::mapet std::vector<std::pair<T, U>>est disponible à partir de 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 vous souhaitez comparer une paire de cartes, vous pouvez utiliser cette méthode:

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

C'est une technique utile.

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