Namespaces
Variants

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

From cppreference.net

C++
Containers library
std::map
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
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.
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.

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::map<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::map<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 konstanten 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

greift auf spezifisches Element mit Grenzprüfung zu
(öffentliche Elementfunktion)
greift auf spezifisches Element zu oder fügt es ein
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück, die einem spezifischen Schlüssel entsprechen
(öffentliche Elementfunktion)
gibt den Bereich der Elemente zurück, die einem spezifischen Schlüssel entsprechen
(öffentliche Elementfunktion)