Namespaces
Variants

std::flat_multimap<Key,T,Compare,KeyContainer,MappedContainer>:: find

From cppreference.net

C++
Containers library
std::flat_multimap
Member types
Member functions
Non-member functions
Helper classes
Tags
Deduction guides
iterator find ( const Key & key ) ;
(1) (seit C++23)
(constexpr seit C++26)
const_iterator find ( const Key & key ) const ;
(2) (seit C++23)
(constexpr seit C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (seit C++23)
(constexpr seit C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (seit C++23)
(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 (siehe end() ) Iterator zurückgegeben.

Komplexität

Logarithmisch in der Größe des Containers.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <flat_map>
struct LightKey
{
    int x;
};
struct FatKey
{
    int x;
    int data[1000]; // ein schwerer Datenblock
};
// Wie oben erläutert, muss der Container std::less<> (oder einen anderen transparenten
// Comparator) verwenden, um diese Überladungen zu nutzen. 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 Vergleichsdemonstration.
    std::flat_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 Vergleichsdemonstration.
    std::flat_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 konstanter Iteratoren.
    // Der Compiler entscheidet, ob ein Iterator vom (nicht-)konstanten Typ zurückgegeben wird,
    // basierend auf dem Zugriff auf die Map; um versehentliche Modifikation zu verhindern, ist
    // eine der einfachsten Optionen, auf die Map über eine konstante Referenz zuzugreifen.
    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)