Namespaces
Variants

std::flat_set<Key,Compare,KeyContainer>:: equal_range

From cppreference.net

C++
Containers library
std::flat_set
Member types
Member functions
Helper classes
Tags
Deduction guides
std:: pair < iterator, iterator > equal_range ( const Key & key ) ;
(1) (desde C++23)
(constexpr desde C++26)
std:: pair < const_iterator, const_iterator >
equal_range ( const Key & key ) const ;
(2) (desde C++23)
(constexpr desde C++26)
template < class K >
std:: pair < iterator, iterator > equal_range ( const K & x ) ;
(3) (desde C++23)
(constexpr desde C++26)
template < class K >

std:: pair < const_iterator, const_iterator >

equal_range ( const K & x ) const ;
(4) (desde C++23)
(constexpr desde C++26)

Devuelve un rango que contiene todos los elementos con la clave dada en el contenedor. El rango está definido por dos iteradores, uno apuntando al primer elemento que no es menor que la clave dada y otro apuntando al primer elemento mayor que la clave dada.

Alternativamente, el primer iterador puede obtenerse con lower_bound() , y el segundo con upper_bound() .

1,2) Compara las claves con key .
3,4) Compara las claves con el valor 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 para comparar los elementos
x - valor alternativo que puede compararse con Key

Valor de retorno

std::pair que contiene un par de iteradores que definen el rango deseado:

  • El primer iterador apunta al primer elemento no menor que la clave dada, o end ( ) si no existe tal elemento.
  • El segundo iterador apunta al primer elemento mayor que la clave dada, o end ( ) si no existe tal elemento.

Complejidad

Logarítmico en el tamaño del contenedor.

Ejemplo

Ejecutar este código 
#include <flat_set>
#include <functional>
#include <print>
#include <ranges>
#include <string>
#include <string_view>
#include <tuple>
struct Names
{
    std::string forename, surname;
    friend auto operator<(const Names& lhs, const Names& rhs)
    {
        return std::tie(lhs.surname, lhs.forename) < std::tie(rhs.surname, rhs.forename);
    }
};
struct SurnameCompare
{
    std::string_view surname;
    friend bool operator<(const Names& lhs, const SurnameCompare& rhs)
    {
        return lhs.surname < rhs.surname;
    }
    friend bool operator<(const SurnameCompare& lhs, const Names& rhs)
    {
        return lhs.surname < rhs.surname;
    }
}; 
std::set<Names, std::less<>> characters
{
    {"Homer", "Simpson"},
    {"Marge", "Simpson"},
    {"Lisa", "Simpson"},
    {"Ned", "Flanders"},
    {"Joe", "Quimby"}
};
void print_unique(const Names& names)
{
    auto [begin, end] = characters.equal_range(names);
    std::print
    (
        "Encontrados {} personajes con nombre \"{} {}\"\n", 
        std::distance(begin, end), 
        names.forename, names.surname
    );
}
void print_by_surname(std::string_view surname)
{
    auto [begin, end] = characters.equal_range(SurnameCompare{surname});
    std::print("Encontrados {} personajes con apellido \"{}\":\n", std::distance(begin, end), surname);
    for (const Names& names : std::ranges::subrange(begin, end))
        std::print("    {} {}\n", names.forename, names.surname);
}
int main()
{
    print_unique({"Maude", "Flanders"});
    print_unique({"Lisa", "Simpson"});
    print_by_surname("Simpson");
}

Salida: 

Encontrados 0 personajes con nombre "Maude Flanders"
Encontrados 1 personajes con nombre "Lisa Simpson"
Encontrados 3 personajes con apellido "Simpson":
    Homer Simpson
    Lisa Simpson
    Marge Simpson

Véase también

encuentra elemento con clave específica
(función miembro pública)
verifica si el contenedor contiene elemento con clave específica
(función miembro pública)
devuelve el número de elementos que coinciden con clave específica
(función miembro pública)
devuelve un iterador al primer elemento mayor que la clave dada
(función miembro pública)
devuelve un iterador al primer elemento no menor que la clave dada
(función miembro pública)
devuelve rango de elementos que coinciden con clave específica
(plantilla de función)