Namespaces
Variants

    std::mismatch

    De es.cppreference.net
     
    C++
    Soporte del compilador
    Independiente y alojado
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos con nombre
    Macros de prueba de características (C++20)
    Biblioteca de soporte del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnóstico
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de utilidades generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de soporte de concurrencia (C++11)
    Biblioteca de control de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de algoritmos
    Algoritmos restringidos y algoritmos sobre rangos (C++20)
    Algoritmos restringidos, ej. ranges::copy, ranges::sort, ...
    Operaciones de secuencia no modificantes    
    Operaciones por lotes
    (C++17)
    Operaciones de búsqueda
    Operaciones de secuencia modificantes
    Operaciones de copia
    (C++11)
    (C++11)
    (C++11)
    Operaciones de intercambio
    Operaciones de transformación
    Operaciones de generación
    Operaciones de eliminación
    Operaciones de cambio de orden
    (hasta C++17)(C++11)
    (C++20)(C++20)
    Operaciones de muestreo
    (C++17)

    Ordenación y operaciones relacionadas
    Operaciones de particionamiento
    (C++11)    
    (C++11)

    Operaciones de ordenación
    Operaciones de búsqueda binaria
    (en rangos particionados)
    Operaciones de conjunto (en rangos ordenados)
    Operaciones de fusión (en rangos ordenados)
    Operaciones de montículo
    Operaciones de mínimo/máximo
    (C++11)
    (C++17)
    Operaciones de comparación lexicográfica
    (C++20)
    Operaciones de permutación


     
    Definido en el encabezado <algorithm> 
    template< class InputIt1, class InputIt2 >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2 );
    		(1) (constexpr desde C++20) 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2 );
    		(2) (desde C++17) 
    template< class InputIt1, class InputIt2, class BinaryPred >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, BinaryPred p );
    		(3) (constexpr desde 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) (desde C++17) 
    template< class InputIt1, class InputIt2 >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2 );
    		(5) (desde C++14)
    (constexpr desde 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) (desde 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) (desde C++14)
    (constexpr desde 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) (desde C++17)

    Devuelve un par de iteradores al primer desajuste de elementos desde [first1, last1) y un rango que comienza desde 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.
    1,5) Los elementos se comparan usando operator==.
    3,7) Los elementos se comparan usando el predicado binario dado p.
    2,4,6,8) Igual que (1,3,5,7), pero ejecutado según policy.
    Estas sobrecargas participan en la resolución de sobrecarga solo si el valor de la siguiente expresión es true:

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

    		(hasta C++20)

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

    		(desde C++20)

    Parámetros

    first1, last1 - el par de iteradores que definen el primer rango de elementos a comparar
    first2, last2 - el par de iteradores que definen el segundo rango de elementos a comparar
    policy - la política de ejecución a usar
    p - predicado binario que devuelve ​true si los elementos deben ser tratados como iguales.

    La firma del predicado debe ser equivalente a la siguiente:

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

    Mientras que la firma no necesita tener const &, la función no debe modificar los objetos que se le pasan y debe poder aceptar todos los valores de tipo (posiblemente const) Type1 y Type2 independientemente de la categoría de valor (por lo tanto, Type1 & no está permitido, ni Type1 a menos que para Type1 un movimiento sea equivalente a una copia(desde C++11)).
    Los tipos Type1 y Type2 deben ser tales que los objetos de tipos InputIt1 y InputIt2 puedan ser desreferenciados y luego convertidos implícitamente a Type1 y Type2 respectivamente. ​

    Requisitos de tipo
    -
    InputIt1 debe cumplir los requisitos de LegacyInputIterator.
    -
    InputIt2 debe cumplir los requisitos de LegacyInputIterator.
    -
    ForwardIt1 debe cumplir los requisitos de LegacyForwardIterator.
    -
    ForwardIt2 debe cumplir los requisitos de LegacyForwardIterator.
    -
    BinaryPred debe cumplir los requisitos de BinaryPredicate.

    Valor de retorno

    std::pair con iteradores a los primeros dos 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 N1 como std::distance(first1, last1) y N2 como std::distance(first2, last2):

    1,2) Como máximo N1 comparaciones usando operator==.
    3,4) Como máximo N1 aplicaciones del predicado p.
    5,6) Como máximo min(N1,N2) comparaciones usando operator==.
    7,8) Como máximo min(N1,N2) aplicaciones del predicado p.

    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 una de las políticas estándar, se llama a std::terminate. Para cualquier otro ExecutionPolicy, el comportamiento está definido por la implementación.
    • Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

    Posible implementación

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

    Ejemplo

    Este programa determina la subcadena más larga que se encuentra simultáneamente al comienzo de la cadena dada y al final de la misma, en orden inverso (posiblemente superponiéndose).

    Ejecutar este código
    #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';
}

    Salida: 

    ab
a
aba

    Véase también

    		 determina si dos conjuntos de elementos son iguales
    (plantilla de función & objeto función algoritmo)
    (C++20)
    (C++11)
    		 encuentra el primer elemento que satisface criterios específicos
    (plantilla de función & objeto función algoritmo)
    (C++20)(C++20)(C++20)
    		compara dos rangos lexicográficamente
    (plantilla de función & objeto función algoritmo)
    (C++20)
    		busca la primera ocurrencia de un rango de elementos
    (plantilla de función & objeto función algoritmo)
    (C++20)
    (C++20)
    		 encuentra la primera posición donde dos rangos difieren
    (objeto función algoritmo)