Namespaces
Variants

    std::mismatch

    Из ru.cppreference.net
     
    C++
    Поддержка компилятора
    Автономное и размещенное
    Язык
    Стандартная библиотека
    Заголовки стандартной библиотеки
    Именованные требования
    Макросы для проверки возможностей (C++20)
    Библиотека поддержки языка
    Библиотека концептов (C++20)
    Библиотека диагностики
    Библиотека управления памятью
    Библиотека метапрограммирования (C++11)
    Библиотека общих утилит
    Библиотека контейнеров
    Библиотека итераторов
    Библиотека диапазонов (C++20)
    Библиотека алгоритмов
    Библиотека строк
    Библиотека обработки текста
    Библиотека численных операций
    Библиотека даты и времени
    Библиотека ввода/вывода
    Библиотека файловой системы (C++17)
    Библиотека поддержки параллелизма (C++11)
    Библиотека управления выполнением (C++26)
    Технические спецификации
    Индекс символов
    Внешние библиотеки
     
    Библиотека алгоритмов
    Ограниченные алгоритмы и алгоритмы над диапазонами (C++20)
    Ограниченные алгоритмы, например ranges::copy, ranges::sort, ...
    Операции последовательностей без изменения    
    Пакетные операции
    (C++17)
    Поисковые операции
    Операции последовательностей с изменением
    Операции копирования
    (C++11)
    (C++11)
    (C++11)
    Операции обмена
    Операции преобразования
    Операции генерации
    Операции удаления
    Операции изменения порядка
    (до C++17)(C++11)
    (C++20)(C++20)
    Операции выборки
    (C++17)

    Сортировка и связанные операции
    Операции разбиения
    (C++11)    
    (C++11)

    Операции сортировки
    Операции бинарного поиска
    (на разбитых диапазонах)
    Операции над множествами (на отсортированных диапазонах)
    Операции слияния (на отсортированных диапазонах)
    Операции с кучей
    Операции минимума/максимума
    (C++11)
    (C++17)
    Операции лексикографического сравнения
    (C++20)
    Операции перестановок


    Политики выполнения(C++17)
    (C++17)
    (C++17)(C++17)(C++17)(C++20)
    (только для пояснения*)(C++26)
    (C++17)(C++17)(C++17)(C++20)

    Численные операции
    (C++11)
        
    (C++17)
    (C++17)
    (C++17)    
    (C++17)
    (C++17)
    (C++17)

    Специализированные<memory>алгоритмы

    Специализированные<random>алгоритмы
    (C++26)
    Библиотека C









     
    Определено в заголовке <algorithm> 
    template< class InputIt1, class InputIt2 >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2 );
    		(1) (constexpr начиная с C++20) 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2 );
    		(2) (начиная с C++17) 
    template< class InputIt1, class InputIt2, class BinaryPred >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, BinaryPred p );
    		(3) (constexpr начиная с C++20) 
    template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryPred >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2, BinaryPred p );
    		(4) (начиная с C++17) 
    template< class InputIt1, class InputIt2 >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2 );
    		(5) (начиная с C++14)
    (constexpr начиная с C++20)    		 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2, ForwardIt2 last2 );
    		(6) (начиная с C++17) 
    template< class InputIt1, class InputIt2, class BinaryPred >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2, BinaryPred p );
    		(7) (начиная с C++14)
    (constexpr начиная с C++20)    		 
    template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryPred >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2, ForwardIt2 last2, BinaryPred p );
    		(8) (начиная с C++17)

    Возвращает пару итераторов на первые несовпадающие элементы из [first1, last1) и диапазона, начинающегося с first2:

    • Для перегрузок (1-4), второй диапазон имеет std::distance(first1, last1) элементов.
    • Для перегрузок (5-8), второй диапазон — это [first2, last2).
    • Если std::distance(first1, last1) и std::distance(first2, last2) различаются, сравнение останавливается при достижении last1 или last2.
    1,5) Элементы сравниваются с помощью operator==.
    3,7) Элементы сравниваются с помощью заданного бинарного предиката p.
    2,4,6,8) То же, что и (1,3,5,7), но выполняется в соответствии с policy.
    Эти перегрузки участвуют в разрешении перегрузки только если значение следующего выражения равно true:

    std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

    		(до C++20)

    std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

    		(начиная с C++20)

    Параметры

    first1, last1 - пара итераторов, определяющая первый диапазон элементов для сравнения
    first2, last2 - пара итераторов, определяющая второй диапазон элементов для сравнения
    policy - политика выполнения для использования
    p - бинарный предикат, который возвращает ​true если элементы следует считать равными.

    Сигнатура функции предиката должна быть эквивалентна следующей:

    bool pred(const Type1 &a, const Type2 &b);

    Хотя сигнатура не обязательно должна содержать const &, функция не должна изменять переданные ей объекты и должна принимать все значения типа (возможно, const) Type1 и Type2 независимо от категории значения (таким образом, Type1 & не допускается, также не допускается Type1 если только для Type1 перемещение не эквивалентно копированию(начиная с C++11)).
    Типы Type1 и Type2 должны быть такими, что объекты типов InputIt1 и InputIt2 могут быть разыменованы и затем неявно преобразованы в Type1 и Type2 соответственно. ​

    Требования к типам
    -
    InputIt1 должен соответствовать требованиям LegacyInputIterator.
    -
    InputIt2 должен соответствовать требованиям LegacyInputIterator.
    -
    ForwardIt1 должен соответствовать требованиям LegacyForwardIterator.
    -
    ForwardIt2 должен соответствовать требованиям LegacyForwardIterator.
    -
    BinaryPred должен соответствовать требованиям BinaryPredicate.

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

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

    Если достигнут last1, второй итератор в паре — это std::distance(first1, last1)-й итератор после first2.

    Для перегрузок (5-8), если достигнут last2, первый итератор в паре — это std::distance(first2, last2)-й итератор после first1.

    Сложность

    Пусть N1 равно std::distance(first1, last1) и N2 равно std::distance(first2, last2):

    1,2) Не более N1 сравнений с помощью operator==.
    3,4) Не более N1 применений предиката p.
    5,6) Не более min(N1,N2) сравнений с помощью operator==.
    7,8) Не более min(N1,N2) применений предиката p.

    Исключения

    Перегрузки с параметром шаблона с именем ExecutionPolicy сообщают об ошибках следующим образом:

    • Если выполнение функции, вызванной в рамках алгоритма, вызывает исключение и ExecutionPolicy является одной из стандартных политик, вызывается std::terminate. Для любого другого ExecutionPolicy поведение определяется реализацией.
    • Если алгоритму не удается выделить память, выбрасывается std::bad_alloc.

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

    mismatch (1) 
    template<class InputIt1, class InputIt2>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2)
{
    while (first1 != last1 && *first1 == *first2)
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}
    mismatch (3) 
    template<class InputIt1, class InputIt2, class BinaryPred>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p)
{
    while (first1 != last1 && p(*first1, *first2))
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}
    mismatch (5) 
    template<class InputIt1, class InputIt2>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
{
    while (first1 != last1 && first2 != last2 && *first1 == *first2)
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}
    mismatch (7) 
    template<class InputIt1, class InputIt2, class BinaryPred>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1,
             InputIt2 first2, InputIt2 last2, BinaryPred p)
{
    while (first1 != last1 && first2 != last2 && p(*first1, *first2))
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}

    Пример

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

    Запустить этот код
    #include <algorithm>
#include <iostream>
#include <string>

std::string mirror_ends(const std::string& in)
{
    return std::string(in.begin(),
                       std::mismatch(in.begin(), in.end(), in.rbegin()).first);
}

int main()
{
    std::cout << mirror_ends("abXYZba") << '\n'
              << mirror_ends("abca") << '\n'
              << mirror_ends("aba") << '\n';
}

    Вывод: 

    ab
a
aba

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

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