So finden Sie heraus, ob ein bestimmter Schlüssel in einer C ++ std :: map vorhanden ist

Ich versuche zu überprüfen, ob sich ein bestimmter Schlüssel in einer Karte befindet und kann es etwas nicht:

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

Wie kann ich also drucken, was in p steht?

Verwenden map::find

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

Verwenden Sie die countElementfunktion auf eine der folgenden Arten , um zu überprüfen, ob ein bestimmter Schlüssel in der Karte vorhanden ist :

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

In der Dokumentation zu map::findheißt es: "Eine andere Mitgliedsfunktion map::countkann verwendet werden, um nur zu überprüfen, ob ein bestimmter Schlüssel vorhanden ist."

In der Dokumentation zu map::countheißt es: "Da alle Elemente in einem Kartencontainer eindeutig sind, kann die Funktion nur 1 (wenn das Element gefunden wird) oder Null (andernfalls) zurückgeben."

Um einen Wert aus der Karte über einen Schlüssel abrufen , dass Sie wissen , existieren, die Verwendung der Karte :: at :

value = m.at(key)

Im Gegensatz Karte :: operator [] , map::atwird nicht einen neuen Schlüssel in der Karte erstellen , wenn der angegebene Schlüssel existiert nicht.

C ++ 20 gibt uns std::map::containsdie Möglichkeit dazu.

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

Sie können verwenden .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 

Wenn Sie eine andere API verwenden möchten, suchen Sie 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";

Ich denke du willst map::find. Wenn m.find("f")gleich ist, m.end()wurde der Schlüssel nicht gefunden. Andernfalls gibt find einen Iterator zurück, der auf das gefundene Element zeigt.

Der Fehler liegt daran, dass p.firstes sich um einen Iterator handelt, der beim Einfügen von Streams nicht funktioniert. Ändern Sie Ihre letzte Zeile in cout << (p.first)->first;. pist ein Paar von Iteratoren, p.firstist ein Iterator, p.first->firstist die Schlüsselzeichenfolge.

Eine Karte kann immer nur ein Element für einen bestimmten Schlüssel haben, equal_rangeist also nicht sehr nützlich. Es ist für die Karte definiert, da es für alle assoziativen Container definiert ist, für Multimap jedoch viel interessanter.

C++17vereinfachte dies etwas mehr mit einem If statement with initializer. Auf diese Weise können Sie Ihren Kuchen haben und ihn auch essen.

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;

Prüfschlüssel vorhanden oder nicht, und Rückgabewert von tritt auf (0/1 in der Karte):

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

Überprüfen Sie, ob der Schlüssel vorhanden ist oder nicht, und geben Sie den Iterator zurück:

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

in Ihrer Frage, verursacht der Fehler durch schlechte operator<<Überlastung, da p.firstist map<string, string>, können Sie es nicht drucken aus. Versuche dies:

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

Wenn Sie schicker werden möchten, können Sie natürlich jederzeit eine Funktion vorlegen, die auch eine gefundene Funktion und eine nicht gefundene Funktion enthält.

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

Und benutze es so:

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

Der Nachteil dabei ist, dass ein guter Name "find_and_execute" unangenehm ist und ich mir nichts Besseres einfallen lassen kann ...

Seien Sie vorsichtig beim Vergleichen des Suchergebnisses mit dem Ende wie für map 'm', da alle Antworten über map :: iterator i = m.find ("f") erfolgen.

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

Sie sollten nicht versuchen, eine Operation wie das Drucken des Schlüssels oder Werts mit dem Iterator i auszuführen, wenn dieser gleich m.end () ist. Andernfalls führt dies zu einem Segmentierungsfehler.

Wenn man den Code von std :: map :: find und std :: map :: count vergleicht, würde ich sagen, dass der erste einen Leistungsvorteil bringen kann:

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

Ich weiß, dass diese Frage bereits einige gute Antworten hat, aber ich denke, meine Lösung ist es wert, geteilt zu werden.

Es funktioniert für beide std::mapund std::vector<std::pair<T, U>>ist in C ++ 11 verfügbar.

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

Wenn Sie ein Kartenpaar vergleichen möchten, können Sie folgende Methode verwenden:

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

Dies ist eine nützliche Technik.

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