Namespaces
Variants

    std::experimental::ranges:: lexicographical_compare

    From es.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    lexicographical_compare


    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    Definido en el encabezado <experimental/ranges/algorithm>
    template < InputIterator I1, Sentinel < I1 > S1, InputIterator I2, Sentinel < I2 > S2,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity ,
    class Comp = ranges:: less <> >
    requires IndirectStrictWeakOrder < Comp, projected < I1, Proj1 > , projected < I2, Proj2 >>
    bool lexicographical_compare ( I1 first1, S1 last1, I2 first2, S2 last2,
    Comp comp = Comp { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(1) (ranges TS)
    template < InputRange R1, InputRange R2,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity ,
    class Comp = ranges:: less <> >
    requires IndirectStrictWeakOrder < Comp, projected < ranges:: iterator_t < R1 > , Proj1 > ,
    projected < ranges:: iterator_t < R2 > , Proj2 >>
    bool lexicographical_compare ( R1 && r1, R2 && r2, Comp comp = Comp { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(2) (ranges TS)
    1) Comprueba si el primer rango [ first1 , last1 ) es lexicográficamente menor que el segundo rango [ first2 , last2 ) . Los elementos se comparan utilizando la función de comparación binaria dada comp , después de ser proyectados con proj1 y proj2 respectivamente.
    2) Igual que (1) , pero utiliza r1 como el primer rango fuente y r2 como el segundo rango fuente, como si se usara ranges:: begin ( r1 ) como first1 , ranges:: end ( r1 ) como last1 , ranges:: begin ( r2 ) como first2 , y ranges:: end ( r2 ) como last2 .

    La comparación lexicográfica es una operación con las siguientes propiedades:

    • Dos rangos se comparan elemento por elemento.
    • El primer elemento que no coincide define qué rango es lexicográficamente menor o mayor que el otro.
    • Si un rango es un prefijo de otro, el rango más corto es lexicográficamente menor que el otro.
    • Si dos rangos tienen elementos equivalentes y son de la misma longitud, entonces los rangos son lexicográficamente iguales .
    • Un rango vacío es lexicográficamente menor que cualquier rango no vacío.
    • Dos rangos vacíos son lexicográficamente iguales .

    Contenido

    Parámetros

    first1, last1 - el primer rango de elementos a examinar
    r1 - el primer rango de elementos a examinar
    first2, last2 - el segundo rango de elementos a examinar
    r2 - el segundo rango de elementos a examinar
    comp - función de comparación a aplicar a los elementos proyectados
    proj1 - proyección a aplicar a los elementos en el primer rango
    proj2 - proyección a aplicar a los elementos en el segundo rango

    Valor de retorno

    true si el primer rango es lexicográficamente menor que el segundo.

    Complejidad

    Como máximo 2·min(N1, N2) aplicaciones de la operación de comparación, donde N1 = last1 - first1 y N2 = last2 - first2 .

    Implementación posible 

    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
         class Proj1 = ranges::identity, class Proj2 = ranges::identity,
         class Comp = ranges::less<>>
    requires IndirectStrictWeakOrder<Comp, projected<I1, Proj1>, projected<I2, Proj2>>
bool lexicographical_compare(I1 first1, S1 last1, I2 first2, S2 last2,
                             Comp comp = Comp{}, 
                             Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{})
{
    for (; (first1 != last1) && (first2 != last2); (void) ++first1, (void) ++first2)
    {
        if (ranges::invoke(comp, ranges::invoke(proj1, *first1),
                                 ranges::invoke(proj2, *first2)))
            return true;
        if (ranges::invoke(comp, ranges::invoke(proj2, *first2),
                                 ranges::invoke(proj1, *first1)))
            return false;
    }
    return (first1 == last1) && (first2 != last2);
}

    Ejemplo

    Esta sección está incompleta
    Motivo: sin ejemplo

    Véase también

    		 compara dos rangos lexicográficamente
    (plantilla de función & objeto de función de algoritmo)
    (C++20)
    		determina si dos conjuntos de elementos son iguales
    (plantilla de función)