std::equal

Défini dans l'en-tête `<algorithm>`
template< class InputIt1, class InputIt2 > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2 );	(1)	(constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > bool equal( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 );	(2)	(depuis C++17)
template< class InputIt1, class InputIt2, class BinaryPred > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p );	(3)	(constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred > bool equal( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, BinaryPred p );	(4)	(depuis C++17)
template< class InputIt1, class InputIt2 > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2 );	(5)	(depuis C++14) (constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > bool equal( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2 );	(6)	(depuis C++17)
template< class InputIt1, class InputIt2, class BinaryPred > bool equal( InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, BinaryPred p );	(7)	(depuis C++14) (constexpr depuis C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPred > bool equal( ExecutionPolicy&& policy, ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2, ForwardIt2 last2, BinaryPred p );	(8)	(depuis C++17)

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

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

1,5) Les éléments sont comparés à l'aide de operator==.

3,7) Les éléments sont comparés à l'aide du prédicat binaire donné p.

2,4,6,8) Identique à (1,3,5,7), mais exécuté selon policy.

Ces surcharges participent à la résolution de surcharge uniquement si la valeur de l'expression suivante est true :

`std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>`	(jusqu'à C++20)
`std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>`	(depuis C++20)

Paramètres

first1, last1	-	la paire d'itérateurs définissant la première plage d'éléments à comparer
first2, last2	-	la paire d'itérateurs définissant la deuxième plage d'éléments à comparer
policy	-	la politique d'exécution à utiliser
p	-	prédicat binaire qui retourne `true` si les éléments doivent être considérés comme égaux. La signature de la fonction prédicat doit être équivalente à la suivante : `bool pred(const Type1 &a, const Type2 &b);` Bien que la signature n'ait pas besoin d'avoir `const &`, la fonction ne doit pas modifier les objets qui lui sont passés et doit pouvoir accepter toutes les valeurs de type (éventuellement const) `Type1` et `Type2` indépendamment de catégorie de valeur (ainsi, `Type1 &` n'est pas autorisé, ni `Type1` sauf si pour `Type1` un déplacement équivaut à une copie(depuis C++11)). Les types `Type1` et `Type2` doivent être tels que les objets de types `InputIt1` et `InputIt2` puissent être déréférencés puis implicitement convertis en `Type1` et `Type2` respectivement.
Exigences de type
- `InputIt1, InputIt2` doit satisfaire les exigences de LegacyInputIterator.
- `ForwardIt1, ForwardIt2` doit satisfaire les exigences de LegacyForwardIterator.
- `BinaryPred` doit satisfaire les exigences de BinaryPredicate.

Valeur de retour

1-4) Si chaque élément correspondant dans les deux plages sont égaux, retourne true. Sinon retourne false.

5-8) Si std::distance(first1, last1) et std::distance(first2, last2) sont égaux, et chaque élément correspondant dans les deux plages sont égaux, retourne true. Sinon retourne false.

Complexité

Étant donné $\scriptsize N_1$ $N 1$ comme std::distance(first1, last1) et $\scriptsize N_2$ $N 2$ comme std::distance(first2, last2) :

1) Au plus

N 1

comparaisons utilisant operator==.

2)

O(N 1)

comparaisons utilisant operator==.

3) Au plus

N 1

applications du prédicat p.

4)

O(N 1)

applications du prédicat p.

5-8) Si InputIt1 et InputIt2 sont tous deux des LegacyRandomAccessIterator, et last1 - first1 != last2 - first2 est true, aucune comparaison ne sera effectuée.

Sinon, étant donné

N

comme

min(N 1,N 2)

:

5) Au plus

N

comparaisons utilisant operator==.

6)

O(N)

comparaisons utilisant operator==.

7) Au plus

N

applications du prédicat p.

8)

O(N)

applications du prédicat p.

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 ExecutionPolicy fait partie des politiques standard, std::terminate est appelée. 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ée.

Implémentation possible

equal (1)
template<class InputIt1, class InputIt2> constexpr //< since C++20 bool equal(InputIt1 first1, InputIt1 last1, InputIt2 first2) { for (; first1 != last1; ++first1, ++first2) if (!(first1 == first2)) return false; return true; }
equal (3)
template<class InputIt1, class InputIt2, class BinaryPred> constexpr //< since 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; }
equal (5)
namespace detail { // random-access iterator implementation (allows quick range size detection) template<class RandomIt1, class RandomIt2> constexpr //< since 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; } // input iterator implementation (needs to manually compare with “last2”) template<class InputIt1, class InputIt2> constexpr //< since 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 //< since 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()); }
equal (7)
namespace detail { // random-access iterator implementation (allows quick range size detection) template<class RandomIt1, class RandomIt2, class BinaryPred> constexpr //< since 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; } // input iterator implementation (needs to manually compare with “last2”) template<class InputIt1, class InputIt2, class BinaryPred> constexpr //< since 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 //< since 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 sont généralement préférés.

Le std::equal séquentiel n'est pas garanti d'être à court-circuit. Par exemple, si les premières paires d'éléments des deux plages ne sont pas égales, le reste des éléments peut également être comparé. Une comparaison non 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

Le code suivant utilise std::equal pour tester si une chaîne est un palindrome.

Exécuter ce code

#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");
}

Sortie :

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

Voir aussi

findfind_iffind_if_not (C++11)	trouve le premier élément satisfaisant des critères spécifiques (modèle de fonction & objet fonction d'algorithme)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)
lexicographical_compare	compare deux plages lexicographiquement (modèle de fonction & objet fonction d'algorithme)
ranges::lexicographical_compare (C++20)
mismatch	trouve la première position où deux plages diffèrent (modèle de fonction & objet fonction d'algorithme)
ranges::mismatch (C++20)
search	recherche la première occurrence d'une plage d'éléments (modèle de fonction & objet fonction d'algorithme)
ranges::search (C++20)
ranges::equal (C++20)	détermine si deux ensembles d'éléments sont identiques (objet fonction d'algorithme)
equal_to	objet fonction implémentant `x == y` (modèle de classe)
equal_range	trouve la plage d'éléments correspondant à la valeur donnée en utilisant une recherche binaire (modèle de fonction & objet fonction d'algorithme)
ranges::equal_range (C++20)

Support du compilateur
Freestanding et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque de numériques
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

fr.cppreference.net

Namespaces

Variants

std::equal

Sommaire

Paramètres

Valeur de retour

Complexité

Exceptions

Implémentation possible

Notes

Exemple

Voir aussi