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

#include <iostream>
#include <map>
 
struct ClavePesada   { int x; int data[1000]; };
struct ClaveLigera { int x; };
// Nota: como se detalla arriba, el contenedor debe usar std::less<>
// (u otro comparador transparente) para acceder a estas sobrecargas.
// Esto incluye las sobrecargas estándar, como entre std::string y std::string_view.
bool operator<(const ClavePesada& fk, const ClaveLigera& lk) { return fk.x < lk.x; }
bool operator<(const ClaveLigera& lk, const ClavePesada& fk) { return lk.x < fk.x; }
bool operator<(const ClavePesada& fk1, const ClavePesada& fk2) { return fk1.x < fk2.x; }
 
int main()
{  
// demo de comparación simple
    std::multimap<int,char> ejemplo = {{1,'a'},{2,'b'}};
 
    auto busqueda = ejemplo.find(2);
    if (busqueda != ejemplo.end()) {
        std::cout << "Se encontró " << busqueda->first << " " << busqueda->second << '\n';
    } else {
        std::cout << "No se encontró\n";
    }
 
// demo de comparación transparente
    std::multimap<ClavePesada, char, std::less<>> ejemplo2 = { { {1, {} },'a'}, { {2, {} },'b'} };
 
    ClaveLigera lk = {2};
    auto busqueda2 = ejemplo2.find(lk);
    if (busqueda2 != ejemplo2.end()) {
        std::cout << "Se encontró " << busqueda2->first.x << " " << busqueda2->second << '\n';
    } else {
        std::cout << "No se encontró\n";
    }
// Obtención de iteradores constantes.
// El compilador decide si devuelve un iterador de tipo (no) const al acceder a
// map; para prevenir modificación intencional, una opción fácil es acceder a map
// mediante referencia const.
    const auto& refejemplo2 = ejemplo2;
    auto busqueda3 = refejemplo2.find(lk);
    if (busqueda3 != ejemplo2.end()) {
        std::cout << "Se encontró " << busqueda3->first.x << ' ' << busqueda3->second << '\n';
    //  busqueda3->second = 'c'; // ERROR: asignación de miembro
                               // 'std::pair<const ClavePesada, char>::second'
                               // en objeto de solo lectura
    }
}