◐ Shell
clean mode source ↗

std::mismatch - cppreference.com

</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>

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)

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).

#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:

Véase también