std:: equal

Vérifie si [ first1 , last1 ) et une plage commençant à first2 sont égales :

• Pour les surcharges (1-4) , la deuxième plage possède std:: distance ( first1, last1 ) éléments.
• Pour les surcharges (5-8) , la deuxième plage est [ first2 , last2 ) .

Paramètres

Valeur de retour

Complexité

Soit \(\scriptsize N_1\) N 1 défini comme std:: distance ( first1, last1 ) et \(\scriptsize N_2\) N 2 défini comme std:: distance ( first2, last2 ) :

Exceptions

Les surcharges avec un paramètre de modèle nommé ExecutionPolicy signalent les erreurs comme suit :

• Si l'exécution d'une fonction invoquée dans le cadre de l'algorithme lève une exception et que ExecutionPolicy fait partie des politiques standard , std::terminate est appelé. Pour tout autre ExecutionPolicy , le comportement est défini par l'implémentation.
• Si l'algorithme ne parvient pas à allouer de la mémoire, std::bad_alloc est levé.

Implémentation possible

template<class InputIt1, class InputIt2>
constexpr //< depuis C++20
bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2)
{
    for (; first1 != last1; ++first1, ++first2)
        if (!(*first1 == *first2))
            return false;
    return true;
}

template<class InputIt1, class InputIt2, class BinaryPred>
constexpr //< depuis C++20
bool equal(InputIt1 first1, InputIt1 last1,
           InputIt2 first2, BinaryPred p)
{
    for (; first1 != last1; ++first1, ++first2)
        if (!p(*first1, *first2))
            return false;
    return true;
}

namespace detail
{
    // implémentation d'itérateur à accès aléatoire (permet une détection rapide de la taille de la plage)
    template<class RandomIt1, class RandomIt2>
    constexpr //< depuis C++20
    bool equal(RandomIt1 first1, RandomIt1 last1, RandomIt2 first2, RandomIt2 last2,
               std::random_access_iterator_tag, std::random_access_iterator_tag)
    {
        if (last1 - first1 != last2 - first2)
            return false;
        for (; first1 != last1; ++first1, ++first2)
            if (!(*first1 == *first2))
                return false;
        return true;
    }
    // implémentation d'itérateur d'entrée (nécessite une comparaison manuelle avec "last2")
    template<class InputIt1, class InputIt2>
    constexpr //< depuis C++20
    bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
               std::input_iterator_tag, std::input_iterator_tag)
    {
        for (; first1 != last1 && first2 != last2; ++first1, ++first2)
            if (!(*first1 == *first2))
                return false;
        return first1 == last1 && first2 == last2;
    }
}
template<class InputIt1, class InputIt2>
constexpr //< depuis C++20
bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
{
    details::equal(first1, last1, first2, last2,
                   typename std::iterator_traits<InputIt1>::iterator_category(),
                   typename std::iterator_traits<InputIt2>::iterator_category());
}

namespace detail
{
    // implémentation d'itérateur à accès aléatoire (permet une détection rapide de la taille de la plage)
    template<class RandomIt1, class RandomIt2, class BinaryPred>
    constexpr //< depuis C++20
    bool equal(RandomIt1 first1, RandomIt1 last1,
               RandomIt2 first2, RandomIt2 last2, BinaryPred p,
               std::random_access_iterator_tag, std::random_access_iterator_tag)
    {
        if (last1 - first1 != last2 - first2)
            return false;
        for (; first1 != last1; ++first1, ++first2)
            if (!p(*first1, *first2))
                return false;
        return true;
    }
    // implémentation d'itérateur d'entrée (doit comparer manuellement avec "last2")
    template<class InputIt1, class InputIt2, class BinaryPred>
    constexpr //< depuis C++20
    bool equal(InputIt1 first1, InputIt1 last1,
               InputIt2 first2, InputIt2 last2, BinaryPred p,
               std::input_iterator_tag, std::input_iterator_tag)
    {
        for (; first1 != last1 && first2 != last2; ++first1, ++first2)
            if (!p(*first1, *first2))
                return false;
        return first1 == last1 && first2 == last2;
    }
}
template<class InputIt1, class InputIt2, class BinaryPred>
constexpr //< depuis C++20
bool equal(InputIt1 first1, InputIt1 last1,
           InputIt2 first2, InputIt2 last2, BinaryPred p)
{
    details::equal(first1, last1, first2, last2, p,
                   typename std::iterator_traits<InputIt1>::iterator_category(),
                   typename std::iterator_traits<InputIt2>::iterator_category());
}

Notes

std::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 (depuis C++17) pour l'égalité, operator == pour le type correspondant est généralement préféré.

L'égalité séquentielle std::equal n'est pas garantie d'être à court-circuit. Par exemple, si la première paire d'é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.

Exemple

#include <algorithm>
#include <iomanip>
#include <iostream>
#include <string_view>
constexpr bool is_palindrome(const std::string_view& s)
{
    return std::equal(s.cbegin(), s.cbegin() + s.size() / 2, s.crbegin());
}
void test(const std::string_view& s)
{
    std::cout << std::quoted(s)
              << (is_palindrome(s) ? " is" : " is not")
              << " a palindrome\n";
}
int main()
{
    test("radar");
    test("hello");
}

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

Voir aussi