Namespaces
Variants

std::multimap<Key,T,Compare,Allocator>:: find

From cppreference.net

C++
Containers library
std::multimap
Member functions
Non-member functions
Deduction guides (C++17)
iterator find ( const Key & key ) ;
(1) (constexpr seit C++26)
const_iterator find ( const Key & key ) const ;
(2) (constexpr seit C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (seit C++14)
(constexpr seit C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (seit C++14)
(constexpr seit C++26)
1,2) Findet ein Element mit einem Schlüssel, der äquivalent zu key ist. Wenn mehrere Elemente mit dem angeforderten Schlüssel im Container vorhanden sind, kann eines davon zurückgegeben werden.
3,4) Findet ein Element mit einem Schlüssel, der äquivalent zu x vergleicht.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn Compare transparent ist. Sie ermöglicht den Aufruf dieser Funktion ohne Konstruktion einer Instanz von Key .

Inhaltsverzeichnis

Parameter

key - Schlüsselwert des zu suchenden Elements
x - ein Wert beliebigen Typs, der transparent mit einem Schlüssel verglichen werden kann

Rückgabewert

Ein Iterator zum angeforderten Element. Wenn kein solches Element gefunden wird, wird ein past-the-end-Iterator (siehe end() ) zurückgegeben.

Komplexität

Logarithmisch in der Größe des Containers.

Hinweise

Feature-Test Makro Wert Std Funktion
__cpp_lib_generic_associative_lookup 201304L (C++14) Heterogener Vergleichslookup in assoziativen Containern ; Überladungen ( 3,4 )

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <map>
struct LightKey
{
    int x;
};
struct FatKey
{
    int x;
    int data[1000]; // ein schwerer Datenblock
};
// Wie oben beschrieben, muss der Container std::less<> (oder einen anderen transparenten
// Comparator) verwenden, um auf diese Überladungen zuzugreifen. Dies umfasst Standardüberladungen,
// wie den Vergleich zwischen std::string und std::string_view.
bool operator<(const FatKey& fk, const LightKey& lk) { return fk.x < lk.x; }
bool operator<(const LightKey& lk, const FatKey& fk) { return lk.x < fk.x; }
bool operator<(const FatKey& fk1, const FatKey& fk2) { return fk1.x < fk2.x; }
int main()
{
    // Einfache Vergleichsdemo.
    std::multimap<int, char> example{{1, 'a'}, {2, 'b'}};
    if (auto search = example.find(2); search != example.end())
        std::cout << "Found " << search->first << ' ' << search->second << '\n';
    else
        std::cout << "Not found\n";
    // Transparente Vergleichsdemo.
    std::multimap<FatKey, char, std::less<>> example2{{{1, {}}, 'a'}, {{2, {}}, 'b'}};
    LightKey lk = {2};
    if (auto search = example2.find(lk); search != example2.end())
        std::cout << "Found " << search->first.x << ' ' << search->second << '\n';
    else
        std::cout << "Not found\n";
    // Abrufen von const-Iteratoren.
    // Der Compiler entscheidet, ob ein Iterator vom (non) const-Typ zurückgegeben wird,
    // basierend auf dem Zugriff auf die Map; um versehentliche Modifikation zu verhindern, ist eine
    // der einfachsten Optionen der Zugriff auf die Map über eine konstante Referenz.
    const auto& example2ref = example2;
    if (auto search = example2ref.find(lk); search != example2.end())
    {
        std::cout << "Found " << search->first.x << ' ' << search->second << '\n';
    //  search->second = 'c'; // Fehler: Zuweisung des Members
                              // 'std::pair<const FatKey, char>::second'
                              // in einem schreibgeschützten Objekt
    }
}

Ausgabe: 

Found 2 b
Found 2 b
Found 2 b

Siehe auch

gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen
(öffentliche Elementfunktion)
gibt den Bereich der Elemente zurück, die einem bestimmten Schlüssel entsprechen
(öffentliche Elementfunktion)