Namespaces
Variants

std::unordered_set<Key,Hash,KeyEqual,Allocator>:: find

From cppreference.net

C++
Containers library
std::unordered_set
Member types
Member functions
Non-member functions
Deduction guides (C++17)
iterator find ( const Key & key ) ;
(1) (seit C++11)
(constexpr seit C++26)
const_iterator find ( const Key & key ) const ;
(2) (seit C++11)
(constexpr seit C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (seit C++20)
(constexpr seit C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (seit C++20)
(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 Hash und KeyEqual beide transparent sind. Dies setzt voraus, dass ein solcher Hash sowohl mit dem Typ K als auch mit dem Typ Key aufrufbar ist und dass der KeyEqual transparent ist, was zusammen den Aufruf dieser Funktion ermöglicht, ohne eine Instanz von Key zu konstruieren.

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

Konstant im Durchschnitt, im schlimmsten Fall linear in der Größe des Containers.

Hinweise

Feature-Test Makro Wert Std Funktion
__cpp_lib_generic_unordered_lookup 201811L (C++20) Heterogener Vergleichslookup in ungeordneten assoziativen Containern ; Überladungen ( 3,4 )

Beispiel

Diesen Code ausführen 
#include <cstddef>
#include <functional>
#include <iostream>
#include <source_location>
#include <string>
#include <string_view>
#include <unordered_set>
using namespace std::literals;
namespace logger { bool enabled{false}; }
inline void who(const std::source_location sloc = std::source_location::current())
{
    if (logger::enabled)
        std::cout << sloc.function_name() << '\n';
}
struct string_hash // C++20's transparent hashing
{
    using hash_type = std::hash<std::string_view>;
    using is_transparent = void;
    std::size_t operator()(const char* str) const
    {
        who();
        return hash_type{}(str);
    }
    std::size_t operator()(std::string_view str) const
    {
        who();
        return hash_type{}(str);
    }
    std::size_t operator()(const std::string& str) const
    {
        who();
        return hash_type{}(str);
    }
};
int main()
{
    std::unordered_set<int> example{1, 2, -10};
    std::cout << "Simple comparison demo:\n" << std::boolalpha;
    if (auto search = example.find(2); search != example.end())
        std::cout << "Found " << *search << '\n';
    else
        std::cout << "Not found\n";
    std::unordered_set<std::string, string_hash, std::equal_to<>> set{"one"s, "two"s};
    logger::enabled = true;
    std::cout << "Heterogeneous lookup for unordered containers (transparent hashing):\n"
              << (set.find("one")   != set.end()) << '\n'
              << (set.find("one"s)  != set.end()) << '\n'
              << (set.find("one"sv) != set.end()) << '\n';
}

Mögliche Ausgabe: 

Simple comparison demo:
Found 2
Heterogeneous lookup for unordered containers (transparent hashing):
std::size_t string_hash::operator()(const char*) const
true
std::size_t string_hash::operator()(const std::string&) const
true
std::size_t string_hash::operator()(std::string_view) const
true

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)