std::ranges::mismatch, std::ranges::mismatch_result - cppreference.com

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:

En la práctica, pueden implementarse como objetos función o con extensiones de compilador especiales.

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.

A lo sumo min(last1 - first1, last2 - first2) aplicaciones del predicado y las proyecciones correspondientes.

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;

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