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) (desde C++11)
(constexpr desde C++26)
const_iterator find ( const Key & key ) const ;
(2) (desde C++11)
(constexpr desde C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (desde C++20)
(constexpr desde C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (desde C++20)
(constexpr desde C++26)
1,2) Encuentra un elemento con clave equivalente a key .
3,4) Encuentra un elemento con clave que se compara como equivalente a x .
Esta sobrecarga participa en la resolución de sobrecarga solo si Hash y KeyEqual son ambos transparentes . Esto asume que dicho Hash es invocable tanto con el tipo K como con el tipo Key , y que el KeyEqual es transparente, lo que, en conjunto, permite llamar a esta función sin construir una instancia de Key .

Contenidos

Parámetros

key - valor clave del elemento a buscar
x - un valor de cualquier tipo que puede compararse transparentemente con una clave

Valor de retorno

Un iterador al elemento solicitado. Si no se encuentra dicho elemento, se devuelve un iterador pasado-el-final (ver end() ).

Complejidad

Constante en promedio, caso lineal en el peor de los casos en el tamaño del contenedor.

Notas

Macro de prueba de características Valor Std Característica
__cpp_lib_generic_unordered_lookup 201811L (C++20) Búsqueda de comparación heterogénea en contenedores asociativos desordenados ; sobrecargas ( 3,4 )

Ejemplo

Ejecutar este código 
#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';
}

Salida posible: 

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

Véase también

devuelve el número de elementos que coinciden con una clave específica
(función miembro pública)
devuelve el rango de elementos que coinciden con una clave específica
(función miembro pública)