std:: mismatch

Devuelve un par de iteradores al primer elemento que no coincide entre [ first1 , last1 ) y un rango que comienza en first2 :

• Para las sobrecargas (1-4) , el segundo rango tiene std:: distance ( first1, last1 ) elementos.
• Para las sobrecargas (5-8) , el segundo rango es [ first2 , last2 ) .

• Si std:: distance ( first1, last1 ) y std:: distance ( first2, last2 ) son diferentes, la comparación se detiene cuando se alcanza last1 o last2 .

Parámetros

Valor de retorno

std::pair con iteradores a los dos primeros elementos no iguales.

Si se alcanza last1 , el segundo iterador en el par es el std:: distance ( first1, last1 ) ésimo iterador después de first2 .

Para las sobrecargas (5-8) , si se alcanza last2 , el primer iterador en el par es el std:: distance ( first2, last2 ) ésimo iterador después de first1 .

Complejidad

Dado \(\scriptsize N_1\) N 1 como std:: distance ( first1, last1 ) y \(\scriptsize N_2\) N 2 como std:: distance ( first2, last2 ) :

Excepciones

Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy reportan errores de la siguiente manera:

• Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y ExecutionPolicy es uno de los standard policies , std::terminate es llamado. Para cualquier otro ExecutionPolicy , el comportamiento está definido por la implementación.
• Si el algoritmo falla al asignar memoria, std::bad_alloc es lanzado.

Implementación posible

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

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

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

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

Ejemplo

#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

Véase también