Namespaces
Variants

std::experimental::ranges:: equal

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

Table des matières

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