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 desde C++26)
const_iterator find ( const Key & key ) const ;
(2) (constexpr desde C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (desde C++14)
(constexpr desde C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (desde C++14)
(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 Compare es transparent . 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 past-the-end (ver end() ).

Complejidad

Logarítmico en el tamaño del contenedor.

Notas

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

Ejemplo

Ejecutar este código 
#include <iostream>
#include <map>
struct LightKey
{
    int x;
};
struct FatKey
{
    int x;
    int data[1000]; // un bloque pesado
};
// Como se detalla arriba, el contenedor debe usar std::less<> (u otro Comparator
// transparente) para acceder a estas sobrecargas. Esto incluye sobrecargas estándar,
// como la comparación entre std::string y 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()
{
    // Demostración simple de comparación.
    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";
    // Demostración de comparación transparente.
    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";
    // Obtención de iteradores constantes.
    // El compilador decide si devolver un iterador de tipo (no) constante mediante
    // el acceso al mapa; para prevenir modificaciones intencionales, una de las
    // opciones más simples es acceder al mapa mediante una referencia constante.
    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: asignación del miembro
                              // 'std::pair<const FatKey, char>::second'
                              // en objeto de solo lectura
    }
}

Salida: 

Found 2 b
Found 2 b
Found 2 b

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)