std::ranges:: equal

Dos rangos se consideran iguales si tienen el mismo número de elementos y cada par de elementos proyectados correspondientes satisface pred . Es decir, std:: invoke ( pred, std:: invoke ( proj1, * first1 ) , std:: invoke ( proj2, * first2 ) ) devuelve true para todos los pares de elementos correspondientes en ambos rangos.

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

• No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
• Ninguno de ellos es visible para la búsqueda dependiente de argumento .
• Cuando cualquiera de ellos es encontrado mediante la búsqueda no calificada normal como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumento queda inhibida.

Parámetros

Valor de retorno

Si la longitud del rango [ first1 , last1 ) no es igual a la longitud del rango [ first2 , last2 ) , devuelve false .

Si los elementos en los dos rangos son iguales después de la proyección, retorna true .

De lo contrario, retorna false .

Notas

ranges::equal no debe utilizarse para comparar los rangos formados por los iteradores de std::unordered_set , std::unordered_multiset , std::unordered_map , o std::unordered_multimap porque el orden en que se almacenan los elementos en esos contenedores puede ser diferente incluso si ambos contenedores almacenan los mismos elementos.

Al comparar contenedores completos o vistas de cadena para igualdad, operator == para el tipo correspondiente generalmente son preferidos.

ranges::equal no está garantizado que realice evaluación de cortocircuito. Por ejemplo, si el primer par de elementos de ambos rangos no son iguales, el resto de elementos también podría compararse. La comparación sin cortocircuito puede ocurrir cuando los rangos se comparan con std::memcmp o algoritmos vectorizados específicos de la implementación.

Complejidad

Como máximo min ( last1 - first1, last2 - first2 ) aplicaciones del predicado y las proyecciones correspondientes.

Sin embargo, si S1 y S2 ambos modelan std::sized_sentinel_for para sus respectivos iteradores, y last1 - first1 ! = last2 - first2 entonces no se realizan aplicaciones del predicado (la discrepancia de tamaño se detecta sin examinar ningún elemento).

Implementación posible

struct equal_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 bool
      operator()(I1 first1, S1 last1, I2 first2, S2 last2,
                 Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const
  {
      if constexpr (std::sized_sentinel_for<S1, I1> and std::sized_sentinel_for<S2, I2>)
          if (std::ranges::distance(first1, last1) != std::ranges::distance(first2, last2))
              return false;
      for (; first1 != last1; ++first1, (void)++first2)
          if (!std::invoke(pred, std::invoke(proj1, *first1), std::invoke(proj2, *first2)))
              return false;
      return true;
  }
  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 bool
      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 equal_fn equal;

Ejemplo

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <ranges>
#include <string_view>
constexpr bool is_palindrome(const std::string_view s)
{
    namespace views = std::views;
    auto forward = s | views::take(s.size() / 2);
    auto backward = s | views::reverse | views::take(s.size() / 2);
    return std::ranges::equal(forward, backward);
}
void test(const std::string_view s)
{
    std::cout << std::quoted(s) << " is "
              << (is_palindrome(s) ? "" : "not ")
              << "a palindrome\n";
}
int main()
{
    test("radar");
    test("hello");
    static_assert(is_palindrome("ABBA") and not is_palindrome("AC/DC"));
}

"radar" is a palindrome
"hello" is not a palindrome

Véase también