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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Container-Bibliothek

Sequenz

array (C++11)

vector

vector<bool>

inplace_vector (C++26)

hive (C++26)

deque

forward_list (C++11)

list

Assoziativ

setzt

multiset

map

multimap

Ungeordnete assoziative

unordered_set (C++11)

unordered_multiset (C++11)

unordered_map (C++11)

unordered_multimap (C++11)

Adapter

stack

queue

priority_queue

flat_set (C++23)

flat_multiset (C++23)

flat_map (C++23)

flat_multimap (C++23)

Ansichten

span (C++20)

mdspan (C++23)

Tabellen

Iterator-Invalidierung

Mitgliedsfunktionstabelle

Nicht-Mitgliedsfunktionstabelle

 

std::multimap

Memberfunktionen

multimap::multimap multimap::~multimap        multimap::operator= multimap::get_allocator

Iteratoren multimap::beginmultimap::cbegin (C++11) multimap::endmultimap::cend (C++11) multimap::rbeginmultimap::crbegin (C++11)    multimap::rendmultimap::crend (C++11) Kapazität multimap::size multimap::max_size multimap::empty Observer multimap::key_comp multimap::value_comp Modifizierer multimap::clear multimap::insert multimap::erase multimap::swap multimap::merge (C++17) multimap::insert_range (C++23) multimap::emplace (C++11) multimap::emplace_hint (C++11) multimap::extract (C++17) Suche multimap::count multimap::find multimap::contains (C++20) multimap::equal_range multimap::lower_bound multimap::upper_bound

Nicht-Member-Funktionen

operator==operator<=> (C++20) std::swap(std::multimap) erase_if(std::multimap) (C++20)   operator!=operator<operator>operator<=operator>= (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)

Deduction guides(C++17)

 

iterator find( const Key& key );	(1)
const_iterator find( const Key& key ) const;	(2)
template< class K > iterator find( const K& x );	(3)	(seit C++14)
template< class K > const_iterator find( const K& x ) const;	(4)	(seit C++14)

1,2) Findet ein Element mit einem Schlüssel, der äquivalent zu key ist. Wenn sich mehrere Elemente mit dem angeforderten Schlüssel im Container befinden, kann jedes von ihnen zurückgegeben werden.

3,4) Sucht nach einem Element mit einem Schlüssel, der mit dem Wert x äquivalent ist. Diese Überladung nimmt nur an der Auflösung von Überladungen teil, wenn der qualifizierte Bezeichner Compare::is_transparent gültig ist und einen Typ bezeichnet. Sie ermöglicht es, diese Funktion aufzurufen, ohne eine Instanz von Key zu konstruieren.

Parameter

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

Rückgabewert

Ein Iterator zu dem angeforderten Element. Wenn kein solches Element gefunden wird, wird der Past-the-end (siehe end()) Iterator zurückgegeben.

Komplexität

Logarithmisch zur Größe des Containers.

Anmerkungen

Feature-Test-Makro	Wert	Std	Feature
__cpp_lib_generic_associative_lookup	201304L	(C++14)	Heterogene Schlüsselsuche in assoziativen Containern; Überladungen (3,4)

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <map>
 
struct LightKey
{
    int x;
};
 
struct FatKey
{
    int x;
    int data[1000]; // a heavy blob
};
 
// As detailed above, the container must use std::less<> (or other transparent
// Comparator) to access these overloads. This includes standard overloads,
// such as comparison between std::string and 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()
{
    // Simple comparison demo.
    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";
 
    // Transparent comparison demo.
    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";
 
    // Obtaining const iterators.
    // Compiler decides whether to return iterator of (non) const type by way of
    // accessing map; to prevent intentional modification, one of the simplest
    // options is to access the map via a constant reference.
    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'; // error: assignment of member
                              // 'std::pair<const FatKey, char>::second'
                              // in read-only object
    }
}

Ausgabe

Found 2 b
Found 2 b
Found 2 b

Siehe auch

zählt	gibt die Anzahl der Elemente zurück, die einem bestimmten Schlüssel entsprechen (public member function)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (public member function)