Namespaces
Variants

    std::experimental::ranges:: equal

    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 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 { } ) ;
    		(1) (ranges TS)
    template < InputRange R1, InputRange R2, class Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    requires 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 >
    requires 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)
    (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 > &&
    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)
    (obsolète)
    1) Retourne true si la plage [ first1 , last1 ) est égale à la plage [ first2 , last2 ) , et false sinon.
    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) , sauf que la deuxième plage est considérée comme se terminant lorsque la première plage est épuisée ou lorsque la première discordance est détectée. Équivalent à return last1 == ranges:: mismatch ( first1, last1, std:: forward < I2 > ( first2_ ) , comp, proj1, proj2 ) . in1 ( ) ;
    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 .

    Deux plages sont considérées égales si elles ont le même nombre d'éléments et si, pour chaque itérateur i dans la plage [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) est true .

    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

    true si les deux plages sont égales, sinon retourne false .

    Notes

    ranges::equal ne doit pas être utilisé pour comparer les plages formées par les itérateurs de std::unordered_set , std::unordered_multiset , std::unordered_map , ou std::unordered_multimap car l'ordre dans lequel les éléments sont stockés dans ces conteneurs peut être différent même si les deux conteneurs stockent les mêmes éléments.

    Lors de la comparaison de conteneurs entiers pour l'égalité, operator== pour le conteneur correspondant est généralement préféré.

    Complexité

    1,2) Si SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > est satisfait et last1 - first1 ! = last2 - first2 , aucune application du prédicat et des projections. Sinon, au plus min( last1 - first1 , last2 - first2 ) applications du prédicat et de chaque projection.
    3,4) Au maximum last1 - first1 applications du prédicat et de chaque projection.

    Implémentation possible 

    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;
}

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

    		 détermine si deux ensembles d'éléments sont identiques
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)
    		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)
    		trouve la première position où deux plages diffèrent
    (modèle de fonction)
    		recherche une plage d'éléments
    (modèle de fonction)