std::equal

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Algorithmenbibliothek

Beschränkte Algorithmen und Algorithmen für Bereiche (C++20)
Beschränkte Algorithmen, z.B. ranges::copy, ranges::sort, ...
Ausführungsrichtlinien (C++17)
is_execution_policy (C++17)   execution::seqexecution::parexecution::par_unseqexecution::unseq (C++17)    (C++17)(C++17)(C++20)	execution::sequenced_policyexecution::parallel_policyexecution::parallel_unsequenced_policyexecution::parallel_unsequenced (C++17)(C++17)(C++17)(C++20)
Nicht-modifizierende Sequenzoperationen Stapeloperationen for_each for_each_n (C++17) Suchoperationen all_ofany_ofnone_of (C++11)                (C++11)(C++11) countcount_if mismatch equal findfind_iffind_if_not (C++11) find_end find_first_of adjacent_find search search_n Modifizierende Sequenzoperationen Kopieroperationen copycopy_if (C++11) copy_backward copy_n (C++11) move (C++11) move_backward (C++11) Tauschoperationen swap iter_swap swap_ranges Transformationsoperationen replacereplace_if transform replace_copyreplace_copy_if Generierungsoperationen fill fill_n generate generate_n Entfernungsoperationen removeremove_if unique remove_copyremove_copy_if unique_copy Ordnungsändernde Operationen reverse reverse_copy rotate rotate_copy random_shuffleshuffle (bis C++17)(C++11) shift_leftshift_right (C++20)(C++20) Stichprobenoperationen sample (C++17)	Sortier- und verwandte Operationen Partitionierungsoperationen partition partition_copy (C++11)   stable_partition is_partitioned (C++11) partition_point (C++11) Sortieroperationen sort stable_sort partial_sort partial_sort_copy is_sorted (C++11) is_sorted_until (C++11) nth_element Binäre Suchoperationen (auf partitionierten Bereichen) lower_bound upper_bound equal_range binary_search Mengenoperationen (auf sortierten Bereichen) includes set_union set_intersection set_difference set_symmetric_difference Zusammenführungsoperationen (auf sortierten Bereichen) merge inplace_merge Heapoperationen push_heap pop_heap make_heap sort_heap is_heap (C++11) is_heap_until (C++11) Minimum/Maximum-Operationen max min minmax (C++11) clamp (C++17) max_element min_element minmax_element (C++11) Lexikographische Vergleichsoperationen lexicographical_compare lexicographical_compare_three_way (C++20) Permutationsoperationen next_permutation prev_permutation is_permutation (C++11) C-Bibliothek qsort bsearch
Numerische Operationen
iota (C++11) inner_product adjacent_difference    accumulate reduce (C++17) transform_reduce (C++17)	partial_sum inclusive_scan (C++17)    exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Operationen auf uninitialisiertem Speicher
uninitialized_copy uninitialized_move (C++17)    uninitialized_fill uninitialized_copy_n (C++11) uninitialized_move_n (C++17) uninitialized_fill_n	destroy (C++17) destroy_n (C++17) destroy_at (C++17) construct_at (C++20)       uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17)

 

Definiert in Header <algorithm>
template< class InputIt1, class InputIt2 > bool equal( InputIt1 first1, InputIt1 last1,             InputIt2 first2 );	(1)	(constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > bool equal( ExecutionPolicy&& policy,             ForwardIt1 first1, ForwardIt1 last1,             ForwardIt2 first2 );	(2)	(seit C++17)
template< class InputIt1, class InputIt2, class BinaryPred > bool equal( InputIt1 first1, InputIt1 last1,             InputIt2 first2, BinaryPred p );	(3)	(constexpr seit C++20)
template< class ExecutionPolicy,           class ForwardIt1, class ForwardIt2, class BinaryPred > bool equal( ExecutionPolicy&& policy,             ForwardIt1 first1, ForwardIt1 last1,             ForwardIt2 first2, BinaryPred p );	(4)	(seit C++17)
template< class InputIt1, class InputIt2 > bool equal( InputIt1 first1, InputIt1 last1,             InputIt2 first2, InputIt2 last2 );	(5)	(seit C++14) (constexpr seit C++20)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > bool equal( ExecutionPolicy&& policy,             ForwardIt1 first1, ForwardIt1 last1,             ForwardIt2 first2, ForwardIt2 last2 );	(6)	(seit C++17)
template< class InputIt1, class InputIt2, class BinaryPred > bool equal( InputIt1 first1, InputIt1 last1,             InputIt2 first2, InputIt2 last2, BinaryPred p );	(7)	(seit C++14) (constexpr seit 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)	(seit C++17)

Prüft, ob der Bereich [first1, last1) und ein von first2 ausgehender Bereich gleich sind

• Für die Überladungen (1-4) hat der zweite Bereich std::distance(first1, last1) Elemente.
• Für die Überladungen (5-8) ist der zweite Bereich [first2, last2).

1,5) Elemente werden mit operator== verglichen.

3,7) Elemente werden mit dem gegebenen binären Prädikat p verglichen.

2,4,6,8) Wie (1,3,5,7), aber entsprechend der policy ausgeführt.

Diese Überladungen nehmen an der Auflösungsauflösung teil, nur wenn alle folgenden Bedingungen erfüllt sind

std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> ist true.	(bis C++20)
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> ist true.	(seit C++20)

Parameter

first1, last1	-	das Iteratorenpaar, das den ersten Bereich der zu vergleichenden Elemente definiert.
first2, last2	-	das Iteratorenpaar, das den zweiten Bereich der zu vergleichenden Elemente definiert.
policy	-	die Ausführungsrichtlinie, die verwendet werden soll
p	-	binäre Prädikatfunktion, die ​true zurückgibt, wenn die Elemente als gleich behandelt werden sollen. Die Signatur der Prädikatfunktion sollte äquivalent zur folgenden sein:  bool pred(const Type1 &a, const Type2 &b); Obwohl die Signatur nicht zwingend const & haben muss, darf die Funktion die ihr übergebenen Objekte nicht modifizieren und muss alle Werte vom Typ (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie akzeptieren können (daher ist Type1 & nicht erlaubt, ebenso wenig wie Type1, es sei denn, für Type1 ist eine Verschiebung gleichbedeutend mit einer Kopie(seit C++11)). Die Typen Type1 und Type2 müssen so beschaffen sein, dass Objekte der Typen InputIt1 und InputIt2 dereferenziert und dann implizit in Type1 bzw. Type2 konvertiert werden können. ​
Typanforderungen
- InputIt1, InputIt2 müssen die Anforderungen an LegacyInputIterator erfüllen.
- ForwardIt1, ForwardIt2 müssen die Anforderungen an LegacyForwardIterator erfüllen.
- BinaryPred muss die Anforderungen an BinaryPredicate erfüllen.

Rückgabewert

1-4) Wenn jedes entsprechende Element in den beiden Bereichen gleich ist, wird true zurückgegeben. Andernfalls wird false zurückgegeben.

5-8) Wenn std::distance(first1, last1) und std::distance(first2, last2) gleich sind und jedes entsprechende Element in den beiden Bereichen gleich ist, wird true zurückgegeben. Andernfalls wird false zurückgegeben.

Komplexität

Gegeben \(\scriptsize N_1\)N1 als std::distance(first1, last1) und \(\scriptsize N_2\)N2 als std::distance(first2, last2)

1) Maximal \(\scriptsize N_1\)N1 Vergleiche mit operator==.

2) \(\scriptsize O(N_1)\)O(N1) Vergleiche mit operator==.

3) Maximal \(\scriptsize N_1\)N1 Anwendungen des Prädikats p.

4) \(\scriptsize O(N_1)\)O(N1) Anwendungen des Prädikats p.

5-8) Wenn InputIt1 und InputIt2 beide LegacyRandomAccessIterator sind und last1 - first1 != last2 - first2 true ist, werden keine Vergleiche durchgeführt.

Andernfalls, gegeben \(\scriptsize N\)N als \(\scriptsize \min(N_1,N_2)\)min(N1,N2)

5) Maximal \(\scriptsize N\)N Vergleiche mit operator==.

6) \(\scriptsize O(N)\)O(N) Vergleiche mit operator==.

7) Maximal \(\scriptsize N\)N Anwendungen des Prädikats p.

8) \(\scriptsize O(N)\)O(N) Anwendungen des Prädikats p.

Ausnahmen

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy berichten Fehler wie folgt

• Wenn die Ausführung einer Funktion, die als Teil des Algorithmus aufgerufen wird, eine Ausnahme auslöst und ExecutionPolicy eine der Standardrichtlinien ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsabhängig.
• Wenn dem Algorithmus der Speicher zur Neuzuweisung fehlt, wird std::bad_alloc ausgelöst.

Mögliche Implementierung

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()); }

Anmerkungen

std::equal sollte nicht verwendet werden, um die Bereiche zu vergleichen, die von den Iteratoren von std::unordered_set, std::unordered_multiset, std::unordered_map oder std::unordered_multimap gebildet werden, da die Reihenfolge, in der die Elemente in diesen Containern gespeichert sind, unterschiedlich sein kann, selbst wenn die beiden Container die gleichen Elemente enthalten.

Beim Vergleichen ganzer Container oder String-Views(seit C++17) auf Gleichheit werden in der Regel die operator== für den entsprechenden Typ bevorzugt.

Sequenzielles std::equal ist nicht garantiert kurzschließend. Z.B. wenn das erste Elementpaar beider Bereiche nicht gleich ist, können auch die restlichen Elemente verglichen werden. Ein nicht-kurzschließender Vergleich kann stattfinden, wenn die Bereiche mit std::memcmp oder implementierungsspezifischen vektorisierten Algorithmen verglichen werden.

Beispiel

Der folgende Code verwendet std::equal, um zu testen, ob ein String ein Palindrom ist.

Führen Sie diesen Code aus

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

Ausgabe

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

Siehe auch

findfind_iffind_if_not (C++11)	Findet das erste Element, das bestimmte Kriterien erfüllt (Funktionstempelat)
lexicographical_compare	gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist (Funktionsvorlage)
mismatch	Findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionstempelat)
search	Sucht nach dem ersten Vorkommen eines Elementbereichs (Funktionstempelat)
ranges::equal (C++20)	Bestimmt, ob zwei Elementmengen gleich sind (Algorithmus-Funktionsobjekt)
equal_to	Funktions-Objekt, das x == y implementiert (Klassen-Template)
equal_range	gibt den Bereich von Elementen zurück, die einem bestimmten Schlüssel entsprechen (Funktionstemplate)