Namespaces
Variants

    std::experimental::ranges:: mismatch

    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 Proj1 = ranges:: identity , class Proj2 = ranges:: identity ,
    class Pred = ranges:: equal_to <> >
    requires IndirectRelation < Pred, projected < I1, Proj1 > , projected < I2, Proj2 >>
    auto mismatch ( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred { } ,
    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } )

    - > ranges:: tagged_pair < tag:: in1 ( I1 ) , tag:: in2 ( I2 ) > ;
    		(1) (ranges TS)
    template < InputRange R1, InputRange R2,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity ,
    class Pred = ranges:: equal_to <> >
    requiere IndirectRelation < Pred, projected < ranges:: iterator_t < R1 > , Proj1 > ,
    projected < ranges:: iterator_t < R2 > , Proj2 >>
    auto mismatch ( R1 && r1, R2 && r2, Pred pred = Pred { } ,
    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } )
    - > ranges:: tagged_pair < tag:: in1 ( ranges:: safe_iterator_t < R1 > ) ,

    tag:: in2 ( ranges:: safe_iterator_t < R2 > ) > ;
    		(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 > &&
    IndirectRelation < Pred, projected < I1, Proj1 > ,
    projected < std:: decay_t < I2 > , Proj2 >>
    auto mismatch ( I1 first1, S1 last1, I2 && first2_, Pred pred = Pred { } ,
    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } )

    - > ranges:: tagged_pair < tag:: in1 ( I1 ) , tag:: in2 ( std:: decay_t < I2 > ) > ;
    		(3) (ranges TS)
    (obsoleto)
    template < InputRange R1, class I2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requiere InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectRelation < Pred, projected < ranges:: iterator_t < R1 > , Proj1 > ,
    projected < std:: decay_t < I2 > , Proj2 >>
    auto mismatch ( R1 && r1, I2 && first2_, Pred pred = Pred { } ,
    Proj1 proj1 = Proj1 { } , Proj2 proj2 = Proj2 { } )
    - > ranges:: tagged_pair < tag:: in1 ( ranges:: safe_iterator_t < Rng1 > ) ,

    tag:: in2 ( std:: decay_t < I2 > ) > ;
    		(4) (ranges TS)
    (obsoleto)
    1) Devuelve el primer par de elementos que no coinciden de dos rangos: uno definido por [ first1 , last1 ) y otro definido por [ first2 , last2 ) .
    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) , pero se comporta como si first2 fuera std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; y last2 fuera ranges :: unreachable { }. El algoritmo subyacente nunca incrementa first2 más de last1 - first1 veces.
    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 .

    Los elementos se comparan utilizando pred con los elementos proyectados de los dos rangos, como si fuera mediante ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * j ) ) .

    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

    Un objeto tagged_pair con iteradores a los primeros dos elementos no iguales (el iterador del primer rango tiene la etiqueta in1 y el iterador del segundo rango tiene la etiqueta in2 ).

    Si no se encuentran discrepancias cuando la comparación alcanza last1 o last2 , lo que ocurra primero, el par contiene el iterador final y el iterador correspondiente del otro rango.

    Complejidad

    Como máximo last1 - first1 aplicaciones del predicado y cada proyección.

    Implementación posible 

    template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
         class Proj1 = ranges::identity, class Proj2 = ranges::identity,
         class Pred = ranges::equal_to<>>
    requires IndirectRelation<Pred, projected<I1, Proj1>, projected<I2, Proj2>>
auto mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{},
              Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{})
    -> ranges::tagged_pair<tag::in1(I1), tag::in2(I2)>
{
    while (first1 != last1 && first2 != last2 &&
           ranges::invoke(pred, ranges::invoke(proj1, *first1),
                                ranges::invoke(proj2, *first2)))
    {
        ++first1;
        ++first2;
    }
    return {first1, first2};
}

    Ejemplo

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

    Véase también

    		 encuentra la primera posición donde dos rangos difieren
    (plantilla de función & objeto de función de algoritmo)
    (C++20)
    		determina si dos conjuntos de elementos son iguales
    (plantilla de función)
    		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)
    		busca un rango de elementos
    (plantilla de función)