Namespaces
Variants

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>:: find

From cppreference.net

C++
Containers library
std::unordered_map
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 retorna 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 Estándar 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 <string>
#include <string_view>
#include <unordered_map>
using namespace std::literals;
struct string_hash
{
    using hash_type = std::hash<std::string_view>;
    using is_transparent = void;
    std::size_t operator()(const char* str) const        { return hash_type{}(str); }
    std::size_t operator()(std::string_view str) const   { return hash_type{}(str); }
    std::size_t operator()(const std::string& str) const { return hash_type{}(str); }
};
int main()
{
    // demostración simple de comparación
    std::unordered_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";
    // Demostración C++20: Búsqueda heterogénea para contenedores desordenados (hashing transparente)
    std::unordered_map<std::string, size_t, string_hash, std::equal_to<>> map{{"one"s, 1}};
    std::cout << std::boolalpha
        << (map.find("one")   != map.end()) << '\n'
        << (map.find("one"s)  != map.end()) << '\n'
        << (map.find("one"sv) != map.end()) << '\n';
}

Salida: 

Found 2 b
true
true
true

Véase también

accede al elemento especificado con verificación de límites
(función miembro pública)
accede o inserta el elemento especificado
(función miembro pública)
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)