std::ranges::mismatch, std::ranges::mismatch_result
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| Signatura de la llamada |
||
template< std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> constexpr mismatch_result<I1, I2> mismatch( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} ); |
(1) | (desde C++20) |
template< ranges::input_range R1, ranges::input_range R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable< ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> constexpr mismatch_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>> mismatch( R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} ); |
(2) | (desde C++20) |
| Tipos auxiliares |
||
template<class I1, class I2> using mismatch_result = ranges::in_in_result<I1, I2>; |
(3) | (desde C++20) |
Devuelve el primer par de elementos proyectados que no coinciden de dos rangos: uno definido por [first1, last1) o r1 y otro definido por [first2,last2) o r2.
1) Los elementos se comparan usando el predicado binario
p dado.2) Igual que (1), pero usa
r como el rango fuente, como si se usara ranges::begin(r) como first y ranges::end(r) como last.Las entidades similares a funciones descritas en esta página son niebloids, es decir:
- Las listas de argumentos de plantilla explícitas no se pueden especificar al llamar a cualquiera de ellas.
- Ninguna de ellas es visible para la búsqueda dependiente de argumentos.
- Cuando alguna de ellas se encuentra mediante la búsqueda normal no calificada como el nombre a la izquierda del operador de llamada a función, se inhibe la búsqueda dependiente de argumentos.
En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.
Parámetros
| first1, last1 | - | Un par iterador-centinela que denota el primer rango de los elementos a comparar. |
| r1 | - | El primer rango de los elementos a comparar. |
| first2, last2 | - | Un par iterador-centinela que denota el segundo rango de los elementos a comparar. |
| r2 | - | El segundo rango de los elementos a comparar. |
| pred | - | El predicado a aplicar a los elementos proyectados. |
| proj1 | - | La proyección a aplicar al primer rango de elementos. |
| proj2 | - | La proyección a aplicar al primer rango de elementos. |
Valor de retorno
ranges::mismatch_result con iteradores a los dos primeros elementos no iguales.
Si no se encuentran discrepancias cuando la comparación llega a last1 o last2, lo que ocurra primero, el objeto contiene el iterador final y el iterador correspondiente del otro rango.
Complejidad
A lo sumo min(last1 - first1, last2 - first2) aplicaciones del predicado y las proyecciones correspondientes.
Posible implementación
struct mismatch_fn {
template<std::input_iterator I1, std::sentinel_for<I1> S1,
std::input_iterator I2, std::sentinel_for<I2> S2,
class Pred = ranges::equal_to,
class Proj1 = std::identity, class Proj2 = std::identity>
requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
constexpr std::mismatch_result<I1, I2>
operator()(I1 first1, S1 last1, I2 first2, S2 last2,
Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) {
if (!std::invoke(pred, std::invoke(proj1, *first1), std::invoke(proj2, *first2))) {
break;
}
}
return {first1, first2};
}
template<ranges::input_range R1, ranges::input_range R2,
class Pred = ranges::equal_to,
class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>,
Pred, Proj1, Proj2>
constexpr
ranges::mismatch_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>>
operator()(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
return (*this)(ranges::begin(r1), ranges::end(r1),
ranges::begin(r2), ranges::end(r2),
std::ref(pred), std::ref(proj1), std::ref(proj2));
}
};
inline constexpr mismatch_fn mismatch;
|
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 <algorithm>
#include <cstddef>
#include <iostream>
#include <ranges>
#include <string_view>
// Dado un texto de entrada, devuelve subcadena más larga
// donde la cadena deja de reflejarse
constexpr std::string_view reflejo_termina(const std::string_view texto)
{
const auto fin = std::ranges::mismatch(texto, texto | std::views::reverse).in1;
const std::size_t longitud = std::ranges::distance(texto.begin(), fin);
return { texto.cbegin(), longitud };
}
int main()
{
std::cout << reflejo_termina("abXYZba") << '\n'
<< reflejo_termina("abca") << '\n'
<< reflejo_termina("ABBA") << '\n'
<< reflejo_termina("anitalavalatina") << '\n';
using namespace std::literals::string_view_literals;
static_assert("123"sv == reflejo_termina("123!@#321"));
static_assert("anitalavalatina"sv == reflejo_termina("anitalavalatina"));
}
Salida:
ab
a
ABBA
anitalavalatina
Véase también
(C++20) |
Determina si dos conjuntos de elementos son iguales. (niebloid) |
(C++20)(C++20)(C++20) |
Encuentra el primer elemento que satisfaga un criterio específico. (niebloid) |
Devuelve true si un rango es lexicográficamente menor que otro. (niebloid) | |
(C++20) |
Busca una subsecuencia de elementos en un rango. (niebloid) |
| Encuentra la primera posición donde dos rangos difieren. (plantilla de función) |