Namespaces
Variants

std::experimental::ranges:: mismatch

From 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.

Contenidos

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)
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)