std::ranges::mismatch, std::ranges::mismatch_result

 

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 mismatch_result<I1, I2>     mismatch( 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 mismatch_result<ranges::borrowed_iterator_t<R1>,                           ranges::borrowed_iterator_t<R2>>     mismatch( R1&& r1, R2&& r2, Pred pred = {},               Proj1 proj1 = {}, Proj2 proj2 = {} );	(2)	(seit C++20)
Hilfstypen
template< class I1, class I2 > using mismatch_result = ranges::in_in_result<I1, I2>;	(3)	(seit C++20)

Gibt das erste nicht übereinstimmende Paar von projizierten Elementen aus zwei Bereichen zurück: eines definiert durch [first1, last1) oder r1 und ein anderes definiert durch [first2, last2) oder r2.

1) Elemente werden mit der gegebenen binären Prädikatfunktion p verglichen.

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.

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	-	Prädikat, das 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

ranges::mismatch_result mit Iteratoren auf die ersten beiden ungleichen Elemente.

Wenn keine Nichtübereinstimmungen gefunden werden, wenn der Vergleich last1 oder last2 erreicht (je nachdem, was zuerst eintritt), enthält das Objekt den End-Iterator und den entsprechenden Iterator aus dem anderen Bereich.

Komplexität

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

Mögliche Implementierung

struct mismatch_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 std::mismatch_result<I1, I2> operator()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}) const { for (; first1 != last1 && first2 != last2; ++first1, (void)++first2) if (not std::invoke(pred, std::invoke(proj1, *first1), std::invoke(proj2, *first2))) break;   return {first1, first2}; }   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 ranges::mismatch_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>> 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 mismatch_fn mismatch;

Beispiel

Dieses Programm ermittelt die längste Teilzeichenkette, die gleichzeitig am Anfang und am Ende der gegebenen Zeichenkette in umgekehrter Reihenfolge gefunden wird (möglicherweise überlappend).

Führen Sie diesen Code aus

#include <algorithm>
#include <iostream>
#include <ranges>
#include <string_view>
 
[[nodiscard]]
constexpr std::string_view mirror_ends(const std::string_view in)
{
    const auto end = std::ranges::mismatch(in, in | std::views::reverse).in1;
    return {in.cbegin(), end};
}
 
int main()
{
    std::cout << mirror_ends("abXYZba") << '\n'
              << mirror_ends("abca") << '\n'
              << mirror_ends("ABBA") << '\n'
              << mirror_ends("level") << '\n';
 
    using namespace std::literals::string_view_literals;
 
    static_assert("123"sv == mirror_ends("123!@#321"));
    static_assert("radar"sv == mirror_ends("radar"));
}

Ausgabe

ab
a
ABBA
level

Siehe auch

ranges::equal (C++20)	Bestimmt, ob zwei Elementmengen gleich sind (Algorithmus-Funktionsobjekt)
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::search (C++20)	Sucht nach dem ersten Vorkommen eines Elementbereichs (Algorithmus-Funktionsobjekt)
mismatch	Findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionstempelat)