std::ranges::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)

 

Eingeschränkte Algorithmen

Alle Namen in diesem Menü gehören zum Namespace std::ranges

Nicht-modifizierende Sequenzoperationen

all_ofany_ofnone_of for_each for_each_n    countcount_if adjacent_find mismatch equal lexicographical_compare    containscontains_subrange (C++23)(C++23) findfind_iffind_if_not find_lastfind_last_iffind_last_if_not (C++23)(C++23)(C++23)   find_end find_first_of search search_n starts_with (C++23) ends_with (C++23)

Modifizierende Sequenzoperationen

copycopy_if copy_n copy_backward    move move_backward shift_leftshift_right (C++23)(C++23)   fill fill_n generate generate_n    transform swap_ranges    shuffle sample removeremove_if replacereplace_if reverse rotate remove_copyremove_copy_if    unique replace_copyreplace_copy_if reverse_copy rotate_copy unique_copy

Partitionierungsoperationen

is_partitioned    partition_point    partition    partition_copy    stable_partition

Sortieroperationen

is_sorted is_sorted_until     sort stable_sort         partial_sort       nth_element partial_sort_copy

Binäre Suchoperationen (auf sortierten Bereichen)

lower_bound         upper_bound         binary_search      equal_range

Mengenoperationen (auf sortierten Bereichen)

merge inplace_merge       set_difference set_intersection    set_union          includes set_symmetric_difference

Heapoperationen

is_heap is_heap_until       make_heap           sort_heap push_heap pop_heap

Minimum/Maximum-Operationen

max max_element         min min_element         minmax minmax_element     clamp

Permutationsoperationen

is_permutation      next_permutation    prev_permutation

Faltoperationen

fold_left (C++23) fold_left_first (C++23)   fold_right (C++23) fold_right_last (C++23)   fold_left_with_iter (C++23) fold_left_first_with_iter (C++23)

Numerische Operationen iota (C++23)             Zufallszahlengenerierung generate_random (C++26)

Operationen auf uninitialisiertem Speicher

construct_at    destroy destroy_n destroy_at uninitialized_copy    uninitialized_move uninitialized_fill uninitialized_copy_n    uninitialized_move_n uninitialized_fill_n uninitialized_default_construct uninitialized_default_construct_n uninitialized_value_construct uninitialized_value_construct_n

Rückgabetypen

in_fun_result in_in_result in_found_result    in_out_result in_in_out_result    in_out_out_result    min_max_result out_value_result (C++23) in_value_result (C++23)

 

Definiert in Header <algorithm>
Aufruf-Signatur
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 > erfordert std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> constexpr bool     equal( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},            Proj1 proj1 = {}, Proj2 proj2 = {} );	(1)	(seit C++20)
template< ranges::input_range R1, ranges::input_range R2,           class Pred = ranges::equal_to,           class Proj1 = std::identity, class Proj2 = std::identity > erfordert std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>,                                     Pred, Proj1, Proj2> constexpr bool     equal( R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(2)	(seit C++20)

1) Gibt true zurück, wenn die projizierten Werte des Bereichs [first1, last1) gleich den projizierten Werten des Bereichs [first2, last2) sind, andernfalls false.

2) Dasselbe wie (1), aber verwendet r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.

Zwei Bereiche gelten als gleich, wenn sie die gleiche Anzahl von Elementen haben und jedes Paar entsprechender projizierter Elemente pred erfüllt. Das heißt, std::invoke(pred, std::invoke(proj1, *first1), std::invoke(proj2, *first2)) gibt true für alle Paare entsprechender Elemente in beiden Bereichen zurück.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als niebloids bekannt), d.h.

• Können explizite Template-Argumentlisten bei keinem von ihnen angegeben werden.
• Keiner von ihnen ist für Argument-abhängige Suche sichtbar.
• Wenn einer von ihnen durch normale unqualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird die Argument-abhängige Suche unterdrückt.

Parameter

first1, last1	-	das Iterator-Sentinel-Paar, das den ersten Bereich der zu vergleichenden Elemente definiert
r1	-	der erste Bereich der zu vergleichenden Elemente
first2, last2	-	das Iterator-Sentinel-Paar, das den zweiten Bereich der zu vergleichenden Elemente definiert
r2	-	der zweite Bereich der zu vergleichenden Elemente
pred	-	binäre Prädikatfunktion, die auf die projizierten Elemente angewendet wird
proj1	-	Projektion, die auf den ersten Bereich der Elemente angewendet wird
proj2	-	Projektion, die auf den zweiten Bereich der Elemente angewendet wird

Rückgabewert

Wenn die Länge des Bereichs [first1, last1) nicht mit der Länge des Bereichs [first2, last2) übereinstimmt, wird false zurückgegeben.

Wenn die Elemente in den beiden Bereichen nach der Projektion gleich sind, wird true zurückgegeben.

Andernfalls wird false zurückgegeben.

Hinweise

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

Beim Vergleich ganzer Container oder String-Views auf Gleichheit werden normalerweise operator== für den entsprechenden Typ bevorzugt.

ranges::equal ist nicht garantiert kurzschlussend. Wenn beispielsweise die ersten Elementpaare beider Bereiche nicht gleich sind, können auch die restlichen Elemente verglichen werden. Ein nicht kurzschlussender Vergleich kann auftreten, wenn die Bereiche mit std::memcmp oder implementierungsspezifischen vektorisierten Algorithmen verglichen werden.

Komplexität

Höchstens min(last1 - first1, last2 - first2) Anwendungen des Prädikats und der entsprechenden Projektionen.

Wenn jedoch S1 und S2 beide std::sized_sentinel_for für ihre jeweiligen Iteratoren modellieren und last1 - first1 != last2 - first2 gilt, werden keine Anwendungen des Prädikats durchgeführt (Größenunterschied wird ohne Blick auf Elemente erkannt).

Mögliche Implementierung

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;

Beispiel

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

Führen Sie diesen Code aus

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

Ausgabe

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

Siehe auch

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