Espacios de nombres
Variantes

    std::mismatch

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios 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 apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Biblioteca de algoritmos
    Políticas de ejecución (C++17)
    Operaciones de secuencia no modificantes
    (C++11)(C++11)(C++11)
    (C++17)
    Operaciones de secuencia modificantes
    Operaciones en almacenamiento no inicializado
    Operaciones de partición
    Operaciones de ordenación
    (C++11)
    (C++11)
    Operaciones de búsqueda binaria
    Operaciones de conjuntos (en rangos ordenados)
    Operaciones de pila
    (C++11)
    (C++11)
    Operaciones mínimo/máximo
    (C++11)
    (C++11)
    (C++17)
    (C++20)
    Permutaciones
    Operaciones numéricas
    Bibliotecas C
     
    <tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>
    Definido en el archivo de encabezado <algorithm>
    (1)
    template< class InputIt1, class InputIt2 > std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2 );
    		 (hasta C++20)
    template< class InputIt1, class InputIt2 > constexpr std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2 );
    		 (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)
    (3)
    template< class InputIt1, class InputIt2, class BinaryPredicate > std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p );
    		 (hasta C++20)
    template< class InputIt1, class InputIt2, class BinaryPredicate > constexpr std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p );
    		 (desde C++20)
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPredicate > std::pair<ForwardIt1,ForwardIt2> mismatch( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, BinaryPredicate p );
    		 (4) (desde C++17)
    (5)
    template< class InputIt1, class InputIt2 > std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );
    		 (desde C++14)
    (hasta C++20)
    template< class InputIt1, class InputIt2 > constexpr std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );
    		 (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)
    (7)
    template< class InputIt1, class InputIt2, class BinaryPredicate > std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate p );
    		 (desde C++14)
    (hasta C++20)
    template< class InputIt1, class InputIt2, class BinaryPredicate > constexpr std::pair<InputIt1,InputIt2> mismatch( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate p );
    		 (desde C++20)
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPredicate > std::pair<ForwardIt1,ForwardIt2> mismatch( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, BinaryPredicate p );
    		 (8) (desde C++17)
    See More

    Devuelve el primer par de elementos que no coinciden de dos rangos: uno definido por [first1, last1) y otro definido por [first2,last2). Si no se proporciona last2 (las sobrecargas (1-4)), denota first2 + (last1 - first1).

    1,5) Los elementos se comparan usando operator==.
    3,7) Los elementos se comparan usando el predicado binario p dado.
    2,4,6,8) Igual que (1,3,5,7), pero ejecutado conforme a la política de ejecución policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que 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) sea verdadera.

    Parámetros

    first1, last1 - El primer rango de los elementos.
    first2, last2 - El primer rango de los elementos.
    policy - La política de ejecución a usar. Véase política de ejecución para más detalles.
    p - Predicado binario que devuelve ​true si los elementos deben tratarse como iguales.

    La signatura de la función predicado deberá ser equivalente a la siguiente:

    bool pred(const Tipo1 &a, const Tipo2 &b);

    Mientras que la signatura no necesita tener const &, la función no debe modificar los objetos que se le han pasado y debe ser capaz de aceptar todos los valores de tipo (posiblemente const) Tipo1 y Tipo2 independientemente de la categoría de valor (por lo tanto, no se permite Tipo1 &, ni Tipo1 a menos que para Tipo1 un movimiento sea equivalente a una copia (desde C++11)).
    Los tipos Tipo1 y Tipo2 deben ser tales que objetos de tipo InputIt1 y InputIt2 pueden ser desreferenciados y luego convertidos implícitamente a Tipo1 and Tipo2 respectively. ​

    Requisitos de tipo
    -
    InputIt1 debe satisfacer los requisitos de InputIterator.
    -
    InputIt2 debe satisfacer los requisitos de InputIterator.
    -
    ForwardIt1 debe satisfacer los requisitos de ForwardIterator.
    -
    ForwardIt2 debe satisfacer los requisitos de ForwardIterator.
    -
    BinaryPredicate debe satisfacer los requisitos de BinaryPredicate.

    Valor de retorno

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

    Si no se encuentran discrepancias cuando la comparación llega a last1, el par contiene last1 y el iterador correspondiente del segundo rango. El comportamiento no está definido si el segundo rango es más corto que el primero.

    		(hasta C++14)

    Si no se encuentran discrepancias cuando la comparación llega a last1 o last2, lo que ocurra primero, el par contiene el iterador final y el iterador correspondiente del otro rango.

    		(desde C++14)

    Complejidad

    1-4) A lo sumo last1 - first1 aplicaciones de operator== o el predicado p.
    5-8) A lo sumo min(last1 - first1, last2 - first2) aplicaciones de operator== o el predicado p.

    Excepciones

    Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan errores tales que:

    • Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
    • Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.

    Posible implementación

    Primera versión 
    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);
}
    Segunda versión 
    template<class InputIt1, class InputIt2, class BinaryPredicate>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPredicate p)
{
    while (first1 != last1 && p(*first1, *first2)) {
        ++first1, ++first2;
    }
    return std::make_pair(first1, first2);
}
    Tercera versión 
    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);
}
    Cuarta versión 
    template<class InputIt1, class InputIt2, class BinaryPredicate>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPredicate 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 principio de la cadena dada y al final de la misma, en orden inverso (posiblemente superpuesta).

    Ejecuta este código
    #include <iostream>
#include <string>
#include <algorithm>

// Dado un texto de entrada, devuelve subcadena más larga
// donde la cadena deja de reflejarse
std::string reflejo_termina(const std::string& texto)
{
    return std::string(texto.begin(),
                       std::mismatch(texto.begin(), texto.end(), texto.rbegin()).first);
}

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

    Salida: 

    ab
a
anitalavalatina

    Véase también

    		 Determina si dos conjuntos de elementos son iguales.
    (plantilla de función) [editar]
    (C++11)
    		 Encuentra el primer elemento que satisfaga un criterio específico.
    (plantilla de función) [editar]
    		Devuelve true si un rango es lexicográficamente menor que otro.
    (plantilla de función) [editar]
    		Busca una subsecuencia de elementos.
    (plantilla de función) [editar]
    (C++20)
    		 Encuentra la primera posición donde dos rangos difieren.
    (niebloid) [editar]