std::ranges::mismatch, std::ranges::mismatch_result

Определено в заголовке `<algorithm>`
Подпись вызова
template< std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> constexpr mismatch_result<I1, I2> mismatch( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(1)	(с C++20)
template< ranges::input_range R1, ranges::input_range R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable< ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> constexpr mismatch_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>> mismatch( R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(2)	(с C++20)
Вспомогательные типы
template< class I1, class I2 > using mismatch_result = ranges::in_in_result<I1, I2>;	(3)	(с C++20)

Возвращает первую несовпадающую пару спроецированных элементов из двух диапазонов: один определён [first1, last1) или r1, а другой — [first2, last2) или r2.

1) Элементы сравниваются с помощью заданного бинарного предиката p.

2) То же, что и (1), но использует r в качестве исходного диапазона, как если бы использовался ranges::begin(r) как first и ranges::end(r) как last.

Функциональные сущности, описанные на этой странице, являются неблоидами, то есть:

Явные списки аргументов шаблонов не могут быть указаны при вызове любого из них.
Ни один из них не виден для поиска аргументов, зависящих от имени.
Когда любой из них обнаружен обычным поиском без квалификатора в качестве имени слева от оператора вызова функции, поиск аргументов, зависящих от имени запрещён.

На практике они могут быть реализованы как объекты функций или с помощью специальных расширений компилятора.

Параметры

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

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

ranges::mismatch_result с итераторами на первые два неравных элемента.

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

Сложность

Максимум std::min(last1 - first1, last2 - first2) применений предиката и соответствующих проекций.

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

struct mismatch_fn
{
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::input_iterator I2, std::sentinel_for<I2> S2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
    constexpr std::mismatch_result<I1, I2>
        operator()(I1 first1, S1 last1, I2 first2, S2 last2,
                   Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        for (; first1 != last1 && first2 != last2; ++first1, (void)++first2)
            if (not std::invoke(pred, std::invoke(proj1, *first1),
                                      std::invoke(proj2, *first2)))
                break;
 
        return {first1, first2};
    }
 
    template<ranges::input_range R1, ranges::input_range R2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>,
                                        Pred, Proj1, Proj2>
    constexpr ranges::mismatch_result<ranges::borrowed_iterator_t<R1>,
                                      ranges::borrowed_iterator_t<R2>>
        operator()(R1&& r1, R2&& r2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2), ranges::end(r2),
                       std::ref(pred), std::ref(proj1), std::ref(proj2));
    }
};
 
inline constexpr mismatch_fn mismatch;

Пример

Эта программа определяет самую длинную подстроку, которая одновременно находится в самом начале и в самом конце заданной строки, в обратном порядке (возможно, перекрывающиеся).

#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
 
[[nodiscard]]
constexpr std::string_view mirror_ends(const std::string_view in)
{
    const auto end = std::ranges::mismatch(in, in | std::views::reverse).in1;
    return {in.cbegin(), end};
}
 
int main()
{
    std::cout << mirror_ends("abXYZba") << '\n'
              << mirror_ends("abca") << '\n'
              << mirror_ends("ABBA") << '\n'
              << mirror_ends("level") << '\n';
 
    using namespace std::literals::string_view_literals;
 
    static_assert("123"sv == mirror_ends("123!@#321"));
    static_assert("radar"sv == mirror_ends("radar"));
}

Вывод:

ab
a
ABBA
level

См. также

ranges::equal (C++20)	определяет, являются ли два набора элементов одинаковыми (неблоид)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	находит первый элемент, удовлетворяющий определённым критериям (неблоид)
ranges::lexicographical_compare (C++20)	возвращает `true` если один диапазон лексикографически меньше другого (неблоид)
ranges::search (C++20)	ищет диапазон элементов (неблоид)
mismatch	находит первую позицию, где два диапазона различаются (шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/ranges/mismatch