Namespaces
Variants

    std::experimental::ranges:: equal

    From es.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    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 Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requiere IndirectlyComparable < I1, I2, Pred, Proj1, Proj2 >
    bool equal ( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(1) (ranges TS)
    template < InputRange R1, InputRange R2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requiere IndirectlyComparable < ranges:: iterator_t < R1 > , ranges:: iterator_t < R2 > ,
    Pred, Proj1, Proj2 >
    bool equal ( R1 && r1, R2 && r2, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(2) (ranges TS)
    template < InputIterator I1, Sentinel < I1 > S1, class I2,

    class Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requiere InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectlyComparable < I1, std:: decay_t < I2 > , Pred, Proj1, Proj2 >
    bool equal ( I1 first1, S1 last1, I2 && first2_, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(3) (ranges TS)
    (obsoleto)
    template < InputRange R1, class I2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectlyComparable < ranges:: iterator_t < R1 > , std:: decay_t < I2 > , Pred, Proj1, Proj2 >
    bool equal ( R1 && r1, I2 && first2_, Pred pred = Pred { } ,

    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } ) ;
    		(4) (ranges TS)
    (obsoleto)
    1) Devuelve true si el rango [ first1 , last1 ) es igual al rango [ first2 , last2 ) , y false en caso contrario.
    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 .
    3) Igual que (1) , excepto que el segundo rango se considera que termina cuando se agota el primer rango o se detecta la primera discrepancia. Equivalente a return last1 == ranges:: mismatch ( first1, last1, std:: forward < I2 > ( first2_ ) , comp, proj1, proj2 ) . in1 ( ) ;
    4) Igual que (3) , pero utiliza r1 como el primer rango fuente, como si se usara ranges:: begin ( r1 ) como first1 y ranges:: end ( r1 ) como last1 .

    Dos rangos se consideran iguales si tienen el mismo número de elementos y, para cada iterador i en el rango [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) es true .

    No obstante las declaraciones representadas anteriormente, el número real y el orden de los parámetros de plantilla para las declaraciones de algoritmos no está especificado. Por lo tanto, si se utilizan argumentos de plantilla explícitos al llamar a un algoritmo, el programa probablemente no sea portable.

    Contenido

    Parámetros

    first1, last1 - el primer rango de los elementos
    r1 - el primer rango de los elementos
    first2, last2 - el segundo rango de los elementos
    r2 - el segundo rango de los elementos
    first2_ - el inicio del segundo rango de los elementos
    pred - predicado para aplicar a los elementos proyectados
    proj1 - proyección para aplicar a los elementos en el primer rango
    proj2 - proyección para aplicar a los elementos en el segundo rango

    Valor de retorno

    true si los dos rangos son iguales, de lo contrario retorna false .

    Notas

    ranges::equal no debe utilizarse para comparar los rangos formados por los iteradores de std::unordered_set , std::unordered_multiset , std::unordered_map , o std::unordered_multimap porque el orden en que se almacenan los elementos en esos contenedores puede ser diferente incluso si ambos contenedores almacenan los mismos elementos.

    Al comparar contenedores completos para igualdad, operator== para el contenedor correspondiente generalmente es preferido.

    Complejidad

    1,2) Si SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > se satisface y last1 - first1 ! = last2 - first2 , no se realizan aplicaciones del predicado y las proyecciones. De lo contrario, como máximo min( last1 - first1 , last2 - first2 ) aplicaciones del predicado y cada proyección.
    3,4) Como máximo last1 - first1 aplicaciones del predicado y cada proyección.

    Implementación posible 

    namespace detail 
{
    template<InputIterator I1, SizedSentinel<I1> S1,
             InputIterator I2, SizedSentinel<I1> S2>
    bool check_size(I1& first1, S1& last1, I2& first2, S2& last2)
    {
        return last1 - first1 != last2 - first2;
    }
    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I1> S2>
    bool check_size(I1& first1, S1& last1, I2& first2, S2& last2)
    {
        return false;
    }
}
template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
         class Pred = ranges::equal_to<>, 
         class Proj1 = ranges::identity, class Proj2 = ranges::identity>
    requires IndirectlyComparable<I1, I2, Pred, Proj1, Proj2>
bool equal(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{},
           Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{}) 
{
    if (detail::check_size(first1, last1, first2, last2))
        return false;
    for (; first1 != last1 && first2 != last2; (void) ++first1, (void)++first2)
        if (!ranges::invoke(pred, ranges::invoke(proj1, *first1), 
                                  ranges::invoke(proj2, *first2)))
            return false;
    return first1 == last1 && first2 == last2;
}

    Ejemplo

    Esta sección está incompleta
    Razón: sin ejemplo

    Véase también

    		 determina si dos conjuntos de elementos son iguales
    (plantilla de función & objeto función de algoritmo)
    (C++20)
    		encuentra el primer elemento que satisface criterios específicos
    (plantilla de función)
    		devuelve true si un rango es lexicográficamente menor que otro
    (plantilla de función)
    		encuentra la primera posición donde dos rangos difieren
    (plantilla de función)
    		busca un rango de elementos
    (plantilla de función)