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
**Примечание:** Весь код C++ внутри тегов ` ` сохранен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.
Определено в заголовке <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 <> >
требует 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 >
требует 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)
(устарело)
template < InputRange R1, class I2, class Pred = ranges:: equal_to <> ,

class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
требует 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)
(устарело)
1) Возвращает первую несовпадающую пару элементов из двух диапазонов: один определяется как [ first1 , last1 ) , а другой — как [ first2 , last2 ) .
2) То же, что и (1) , но использует r1 в качестве первого исходного диапазона и r2 в качестве второго исходного диапазона, как если бы использовались ranges:: begin ( r1 ) как first1 , ranges:: end ( r1 ) как last1 , ranges:: begin ( r2 ) как first2 , и ranges:: end ( r2 ) как last2 .
3) То же, что и (1) , но ведёт себя так, как если бы first2 был std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; , а last2 был ranges :: unreachable { }. Базовый алгоритм никогда не инкрементирует first2 более last1 - first1 раз.
4) То же, что и (3) , но использует r1 в качестве первого исходного диапазона, как если бы использовалось ranges:: begin ( r1 ) в качестве first1 и ranges:: end ( r1 ) в качестве last1 .

Элементы сравниваются с использованием pred для проецируемых элементов двух диапазонов, как если бы с помощью ranges:: invoke ( pred, ranges:: invoke ( proj1, * i ) , ranges:: invoke ( proj2, * j ) ) .

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

Содержание

Параметры

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

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

Объект tagged_pair с итераторами на первые два неравных элемента (итератор из первого диапазона имеет тег in1 , а итератор из второго диапазона имеет тег in2 ).

Если при сравнении не обнаружено несоответствий до достижения last1 или last2 (в зависимости от того, что наступит раньше), пара содержит конечный итератор и соответствующий итератор из другого диапазона.

Сложность

Не более last1 - first1 применений предиката и каждой проекции.

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

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};
}
**Примечание:** Весь код C++ внутри тегов ` 
` и `` оставлен без изменений, как и требовалось. HTML-теги и атрибуты также сохранены в оригинальном виде.

Пример

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

Смотрите также

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