std:: equal

From cppreference.net

Definiert im 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 [ first1 , last1 ) und ein Bereich beginnend bei first2 gleich sind:

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

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

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

2,4,6,8) Gleich wie (1,3,5,7) , aber ausgeführt gemäß policy .

Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, 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)

Inhaltsverzeichnis

Parameter

first1, last1	-	das Paar von Iteratoren, das den ersten Bereich der zu vergleichenden Elemente definiert
first2, last2	-	das Paar von Iteratoren, das den zweiten Bereich der zu vergleichenden Elemente definiert
policy	-	die zu verwendende Ausführungsrichtlinie
p	-	binäres Prädikat, das true zurückgibt, wenn die Elemente als gleich behandelt werden sollen. Die Signatur der Prädikatfunktion sollte äquivalent zu Folgendem sein: bool pred ( const Type1 & a, const Type2 & b ) ; Obwohl die Signatur nicht const & benötigt, darf die Funktion die übergebenen Objekte nicht modifizieren und muss alle Werte der Typen (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 äquivalent zu 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 von LegacyInputIterator erfüllen.
- `ForwardIt1, ForwardIt2` müssen die Anforderungen von LegacyForwardIterator erfüllen.
- `BinaryPred` müssen die Anforderungen von BinaryPredicate erfüllen.

Rückgabewert

1-4) Wenn alle entsprechenden Elemente in den beiden Bereichen gleich sind, 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$ $N 1$ als std:: distance ( first1, last1 ) und $\scriptsize N_2$ $N 2$ als std:: distance ( first2, last2 ) :

1) Höchstens

N 1

Vergleiche mit operator == .

O(N 1)

Vergleiche mit operator == .

3) Höchstens

N 1

Anwendungen des Prädikats p .

O(N 1)

Anwendungen des Prädikats p .

5-8) Falls


        InputIt1

und


        InputIt2

beide LegacyRandomAccessIterator sind, und last1 - first1 ! = last2 - first2 true ist, werden keine Vergleiche durchgeführt.

Andernfalls, gegeben

N

als

min(N 1,N 2)

5) Höchstens

N

Vergleiche mit operator == .

O(N)

Vergleiche unter Verwendung von operator == .

7) Höchstens

N

Anwendungen des Prädikats p .

O(N)

Anwendungen des Prädikats p .

Ausnahmen

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

Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung

equal (1)
template<class InputIt1, class InputIt2> constexpr //< seit 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 //< seit 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 { // Implementierung für Random-Access-Iteratoren (ermöglicht schnelle Bereichsgrößenermittlung) template<class RandomIt1, class RandomIt2> constexpr //< seit 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; } // Implementierung für Input-Iteratoren (muss manuell mit "last2" vergleichen) template<class InputIt1, class InputIt2> constexpr //< seit 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 //< seit 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 { // Implementierung für Random-Access-Iteratoren (ermöglicht schnelle Bereichsgrößenermittlung) template<class RandomIt1, class RandomIt2, class BinaryPred> constexpr //< seit 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; } // Implementierung für Input-Iteratoren (muss "last2" manuell vergleichen) template<class InputIt1, class InputIt2, class BinaryPred> constexpr //< seit 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 //< seit 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()); }

Hinweise

std::equal sollte nicht verwendet werden, um die Bereiche zu vergleichen, die von den Iteratoren aus 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 beide Container dieselben Elemente speichern.

Beim Vergleichen gesamter Container oder String-Views (since C++17) auf Gleichheit wird normalerweise operator == für den entsprechenden Typ bevorzugt.

Sequential std::equal garantiert kein Short-Circuit-Verhalten. Wenn beispielsweise das erste Elementpaar beider Bereiche nicht gleich ist, können trotzdem die restlichen Elemente verglichen werden. Ein Nicht-Short-Circuit-Vergriff kann auftreten, wenn die Bereiche mit std::memcmp oder implementationsspezifischen vektorisierten Algorithmen verglichen werden.

Beispiel

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

Diesen Code ausführen

#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

find find_if find_if_not (C++11)	findet das erste Element, das bestimmte Kriterien erfüllt (Funktions-Template)
lexicographical_compare	gibt true zurück, falls ein Bereich lexikographisch kleiner als ein anderer ist (Funktions-Template)
mismatch	findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktions-Template)
search	sucht nach dem ersten Vorkommen eines Elementbereichs (Funktions-Template)
ranges::equal (C++20)	bestimmt, ob zwei Elementmengen identisch sind (Algorithmus-Funktionsobjekt)
equal_to	Funktionsobjekt, das x == y implementiert (Klassen-Template)
equal_range	gibt den Bereich der Elemente zurück, die einem spezifischen Schlüssel entsprechen (Funktions-Template)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

std:: equal

Inhaltsverzeichnis

Parameter

Rückgabewert

Komplexität

Ausnahmen

Mögliche Implementierung

Hinweise

Beispiel

Siehe auch