Namespaces
Variants

    std::experimental::ranges:: mismatch

    From fr.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
    Défini dans l'en-tête <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 <> >
    requires 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 >
    requires 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)
    (obsolète)
    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 > &&
    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)
    (obsolète)
    1) Retourne la première paire d'éléments discordants de deux plages : l'une définie par [ first1 , last1 ) et l'autre définie par [ first2 , last2 ) .
    2) Identique à (1) , mais utilise r1 comme première plage source et r2 comme deuxième plage source, comme si on utilisait ranges:: begin ( r1 ) comme first1 , ranges:: end ( r1 ) comme last1 , ranges:: begin ( r2 ) comme first2 , et ranges:: end ( r2 ) comme last2 .
    3) Identique à (1) , mais se comporte comme si first2 était std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; et last2 était ranges :: unreachable { }. L'algorithme sous-jacent n'incrémente jamais first2 plus de last1 - first1 fois.
    4) Identique à (3) , mais utilise r1 comme première plage source, comme si on utilisait ranges:: begin ( r1 ) comme first1 et ranges:: end ( r1 ) comme last1 .

    Les éléments sont comparés en utilisant pred sur les éléments projetés des deux plages, comme par ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * j ) ) .

    Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

    Sommaire

    Paramètres

    first1, last1 - la première plage des éléments
    r1 - la première plage des éléments
    first2, last2 - la deuxième plage des éléments
    r2 - la deuxième plage des éléments
    first2_ - le début de la deuxième plage des éléments
    pred - prédicat à appliquer aux éléments projetés
    proj1 - projection à appliquer aux éléments de la première plage
    proj2 - projection à appliquer aux éléments de la deuxième plage

    Valeur de retour

    Un objet tagged_pair avec des itérateurs vers les deux premiers éléments non égaux (l'itérateur de la première plage possède le tag in1 et l'itérateur de la seconde plage possède le tag in2 ).

    Si aucune discordance n'est trouvée lorsque la comparaison atteint last1 ou last2 , selon ce qui se produit en premier, la paire contient l'itérateur de fin et l'itérateur correspondant de l'autre plage.

    Complexité

    Au plus last1 - first1 applications du prédicat et de chaque projection.

    Implémentation possible 

    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};
}
    **Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il se trouve dans des balises ` 
    ` et contient des termes spécifiques au C++ qui doivent être préservés. Seul le texte environnant a été traduit, mais dans ce cas précis, il n'y avait pas de texte à traduire en dehors du code C++.

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

    		 trouve la première position où deux plages diffèrent
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    		détermine si deux ensembles d'éléments sont les mêmes
    (modèle de fonction)
    		trouve le premier élément satisfaisant des critères spécifiques
    (modèle de fonction)
    		retourne true si une plage est lexicographiquement inférieure à une autre
    (modèle de fonction)
    		recherche une plage d'éléments
    (modèle de fonction)