Namespaces
Variants

    std::experimental::ranges:: equal

    From ru.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
    Определено в заголовке <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 >
    требует 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 >
    требует 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)
    (устарело)
    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)
    (устарело)
    1) Возвращает true , если диапазон [ first1 , last1 ) равен диапазону [ first2 , last2 ) , и false в противном случае.
    2) То же, что и (1) , но использует r1 в качестве первого исходного диапазона и r2 в качестве второго исходного диапазона, как если бы использовались ranges:: begin ( r1 ) как first1 , ranges:: end ( r1 ) как last1 , ranges:: begin ( r2 ) как first2 , и ranges:: end ( r2 ) как last2 .
    3) То же, что и (1) , за исключением того, что второй диапазон считается завершённым, когда либо исчерпан первый диапазон, либо обнаружено первое несоответствие. Эквивалентно return last1 == ranges:: mismatch ( first1, last1, std:: forward < I2 > ( first2_ ) , comp, proj1, proj2 ) . in1 ( ) ;
    4) То же, что и (3) , но использует r1 в качестве первого исходного диапазона, как если бы использовалось ranges:: begin ( r1 ) в качестве first1 и ranges:: end ( r1 ) в качестве last1 .

    Два диапазона считаются равными, если они имеют одинаковое количество элементов и для каждого итератора i в диапазоне [ first1 , last1 ) , ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * ( first2 + ( i - first1 ) ) ) ) является true .

    Несмотря на приведённые выше объявления, фактическое количество и порядок параметров шаблона для объявлений алгоритмов не определено. Таким образом, если при вызове алгоритма используются явные аргументы шаблона, программа, вероятно, является непереносимой.

    Содержание

    Параметры

    first1, last1 - первый диапазон элементов
    r1 - первый диапазон элементов
    first2, last2 - второй диапазон элементов
    r2 - второй диапазон элементов
    first2_ - начало второго диапазона элементов
    pred - предикат, применяемый к проецируемым элементам
    proj1 - проекция, применяемая к элементам первого диапазона
    proj2 - проекция, применяемая к элементам второго диапазона

    Возвращаемое значение

    true если два диапазона равны, в противном случае возвращает false .

    Примечания

    ranges::equal не следует использовать для сравнения диапазонов, образованных итераторами из std::unordered_set , std::unordered_multiset , std::unordered_map или std::unordered_multimap , поскольку порядок хранения элементов в этих контейнерах может различаться даже при идентичном наборе элементов.

    При сравнении контейнеров целиком на равенство, operator== для соответствующего контейнера обычно предпочтительнее.

    Сложность

    1,2) Если SizedSentinel < S1, I1 > && SizedSentinel < S2, I2 > выполняется и last1 - first1 ! = last2 - first2 , применения предиката и проекций не происходит. В противном случае — не более min( last1 - first1 , last2 - first2 ) применений предиката и каждой проекции.
    3,4) Максимум last1 - first1 применений предиката и каждой проекции.

    Возможная реализация 

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

    Пример

    Этот раздел не завершён
    Причина: отсутствует пример

    См. также

    		 определяет, являются ли два набора элементов одинаковыми
    (шаблон функции & объект-функция алгоритма)
    (C++20)
    		находит первый элемент, удовлетворяющий определенным критериям
    (шаблон функции)
    		возвращает true true, если одна последовательность лексикографически меньше другой
    (шаблон функции)
    		находит первую позицию, где две последовательности различаются
    (шаблон функции)
    		ищет диапазон элементов
    (шаблон функции)