std::experimental::ranges::mismatch

Definiert in Header `<experimental/ranges/algorithm>`
template< InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2, class Proj1 = ranges::identity, class Proj2 = ranges::identity, class Präd = ranges::equal_to<> > requires IndirectRelation<Präd, projected<I1, Proj1>, projected<I2, Proj2>> auto mismatch( I1 first1, S1 last1, I2 first2, S2 last2, Präd pred = Präd{}, Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{} ) -> ranges::tagged_pair<tag::in1(I1), tag::in2(I2)>;	(1)	(Ranges TS)
template< InputRange R1, InputRange R2, class Proj1 = ranges::identity, class Proj2 = ranges::identity, class Präd = ranges::equal_to<> > requires IndirectRelation<Präd, projected<ranges::iterator_t<R1>, Proj1>, projected<ranges::iterator_t<R2>, Proj2>> auto mismatch( R1&& r1, R2&& r2, Präd pred = Präd{}, Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{} ) -> ranges::tagged_pair<tag::in1(ranges::safe_iterator_t<R1>), tag::in2(ranges::safe_iterator_t<R2>)>;	(2)	(Ranges TS)
template< InputIterator I1, Sentinel<I1> S1, class I2, class Präd = ranges::equal_to<>, class Proj1 = ranges::identity, class Proj2 = ranges::identity > requires InputIterator<std::decay_t<I2>> && !Range<I2> && IndirectRelation<Präd, projected<I1, Proj1>, projected<std::decay_t<I2>, Proj2>> auto mismatch( I1 first1, S1 last1, I2&& first2_, Präd pred = Präd{}, Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{} ) -> ranges::tagged_pair<tag::in1(I1), tag::in2(std::decay_t<I2>)>;	(3)	(Ranges TS) (veraltet)
template< InputRange R1, class I2, class Präd = ranges::equal_to<>, class Proj1 = ranges::identity, class Proj2 = ranges::identity > requires InputIterator<std::decay_t<I2>> && !Range<I2> && IndirectRelation<Präd, projected<ranges::iterator_t<R1>, Proj1>, projected<std::decay_t<I2>, Proj2>> auto mismatch( R1&& r1, I2&& first2_, Präd pred = Präd{}, Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{} ) -> ranges::tagged_pair<tag::in1(ranges::safe_iterator_t<Rng1>), tag::in2(std::decay_t<I2>)>;	(4)	(Ranges TS) (veraltet)

1) Gibt das erste nicht übereinstimmende Elementpaar aus zwei Bereichen zurück: eines definiert durch [first1, last1) und ein anderes definiert durch [first2, last2).

2) Wie in (1), verwendet aber r1 als ersten Quellbereich und r2 als zweiten Quellbereich, als ob ranges::begin(r1) als first1, ranges::end(r1) als last1, ranges::begin(r2) als first2 und ranges::end(r2) als last2 verwendet würde.

3) Wie in (1), aber verhält sich so, als ob first2 std::decay_t<I2> first2 = std::forward<I2>(first2_); und last2 ranges::unreachable{ wäre. Der zugrunde liegende Algorithmus inkrementiert first2 nie mehr als last1 - first1 Mal.

4) Dasselbe wie (3), verwendet aber r1 als ersten Quellbereich, als ob ranges::begin(r1) als first1 und ranges::end(r1) als last1 verwendet würden.

Elemente werden mit pred auf die projizierten Elemente der beiden Bereiche angewendet, als ob durch ranges::invoke(pred, ranges::invoke(proj1, *i), ranges::invoke(proj2, *j)).

Ungeachtet der oben gezeigten Deklarationen ist die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmusdeklarationen nicht spezifiziert. Wenn also explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden, ist das Programm wahrscheinlich nicht portabel.

[bearbeiten] Parameter

first1, last1	-	der erste Bereich der Elemente
r1	-	der erste Bereich der Elemente
first2, last2	-	der zweite Bereich der Elemente
r2	-	der zweite Bereich der Elemente
first2_	-	der Anfang des zweiten Bereichs der Elemente
pred	-	Prädikat, das auf die projizierten Elemente angewendet wird
proj1	-	Projektion, die auf die Elemente im ersten Bereich angewendet wird
proj2	-	Projektion, die auf die Elemente im zweiten Bereich angewendet wird

[bearbeiten] Rückgabewert

Ein tagged_pair-Objekt mit Iteratoren zu den ersten beiden nicht übereinstimmenden Elementen (der Iterator aus dem ersten Bereich hat den Tag in1 und der Iterator aus dem zweiten Bereich hat den Tag in2).

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

[bearbeiten] Komplexität

Höchstens last1 - first1 Anwendungen des Prädikats und jeder Projektion.

[bearbeiten] Mögliche Implementierung

template<InputIterator I1, Sentinel<I1> S1, InputIterator I2, Sentinel<I2> S2,
         class Proj1 = ranges::identity, class Proj2 = ranges::identity,
         class Pred = ranges::equal_to<>>
    requires IndirectRelation<Pred, projected<I1, Proj1>, projected<I2, Proj2>>
auto mismatch(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = Pred{},
              Proj1 proj1 = Proj1{}, Proj2 proj2 = Proj2{})
    -> ranges::tagged_pair<tag::in1(I1), tag::in2(I2)>
{
    while (first1 != last1 && first2 != last2 &&
           ranges::invoke(pred, ranges::invoke(proj1, *first1),
                                ranges::invoke(proj2, *first2)))
    {
        ++first1;
        ++first2;
    }
    return {first1, first2};
}

[bearbeiten] Beispiel

[bearbeiten] Siehe auch

mismatch	Findet die erste Position, an der sich zwei Bereiche unterscheiden (Funktionstempelat) [edit]
equal	Bestimmt, ob zwei Elementmengen gleich sind (Funktionsvorlage) [bearbeiten]
findfind_iffind_if_not	Findet das erste Element, das bestimmte Kriterien erfüllt (Funktionsvorlage) [bearbeiten]
lexicographical_compare	gibt true zurück, wenn ein Bereich lexikographisch kleiner als ein anderer ist (Funktionsvorlage) [bearbeiten]
search	sucht nach einem Bereich von Elementen (Funktionsvorlage) [bearbeiten]

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

Technische Spezifikation
Dateisystembibliothek (Filesystem TS)
Grundlagen der Bibliothek (Library Fundamentals TS)
Grundlagen der Bibliothek 2 (Library Fundamentals TS v2)
Grundlagen der Bibliothek 3 (Library Fundamentals TS v3)
Erweiterungen für Parallelität (Parallelism TS)
Erweiterungen für Parallelität 2 (Parallelism TS v2)
Erweiterungen für Nebenläufigkeit (Concurrency TS)
Erweiterungen für Nebenläufigkeit 2 (Concurrency TS v2)
Konzepte (Concepts TS)
Bereiche (Ranges TS)
Reflektion (Reflection TS)
Mathematische Spezialfunktionen (Special Functions TR)
Experimentell Nicht-TS
Pattern Matching
Lineare Algebra
std::execution
Verträge
2D-Grafik

Konzepte
Allgemeine Hilfsmittel
Iteratoren
Bereiche (Ranges)
Algorithmen

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen