std::ranges:: equal

Deux plages sont considérées égales si elles ont le même nombre d'éléments et si chaque paire d'éléments projetés correspondants satisfait pred . C'est-à-dire que std:: invoke ( pred, std:: invoke ( proj1, * first1 ) , std:: invoke ( proj2, * first2 ) ) renvoie true pour toutes les paires d'éléments correspondants dans les deux plages.

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement appelés niebloids ), c'est-à-dire :

• Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
• Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
• Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Paramètres

Valeur de retour

Si la longueur de la plage [ first1 , last1 ) n'est pas égale à la longueur de la plage [ first2 , last2 ) , retourne false .

Si les éléments des deux plages sont égaux après projection, retourne true .

Sinon, retourne false .

Notes

ranges::equal ne doit pas être utilisé pour comparer les plages formées par les itérateurs de std::unordered_set , std::unordered_multiset , std::unordered_map , ou std::unordered_multimap car l'ordre dans lequel les éléments sont stockés dans ces conteneurs peut être différent même si les deux conteneurs stockent les mêmes éléments.

Lors de la comparaison de conteneurs entiers ou de vues de chaînes pour l'égalité, operator == pour le type correspondant sont généralement préférés.

ranges::equal n'est pas garanti d'être à court-circuit. Par exemple, si les premiers éléments des deux plages ne sont pas égaux, le reste des éléments peut également être comparé. Une comparaison sans court-circuit peut se produire lorsque les plages sont comparées avec std::memcmp ou des algorithmes vectorisés spécifiques à l'implémentation.

Complexité

Au plus min ( last1 - first1, last2 - first2 ) applications du prédicat et des projections correspondantes.

Cependant, si S1 et S2 modélisent tous deux std::sized_sentinel_for pour leurs itérateurs respectifs, et si last1 - first1 ! = last2 - first2 alors aucune application du prédicat n'est effectuée (la différence de taille est détectée sans examiner aucun élément).

Implémentation possible

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;

Exemple

#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

Voir aussi