Namespaces
Variants

    std::experimental::ranges:: mismatch

    From de.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    Modifying sequence operations
    Partitioning operations
    Sorting operations
    Binary search operations
    Set operations (on sorted ranges)
    Heap operations
    Minimum/maximum operations
    Permutations
    (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags leer sind. Die Struktur bleibt unverändert, wie angefordert.)
    template < InputIterator I1, Sentinel < I1 > S1, InputIterator I2, Sentinel < I2 > S2,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity ,
    class Pred = ranges:: equal_to <> >
    erfordert 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 ) > ;
    		(1) (ranges TS)
    template < InputRange R1, InputRange R2,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity ,
    class Pred = ranges:: equal_to <> >
    requires IndirectRelation < Pred, projected < ranges:: iterator_t < R1 > , Proj1 > ,
    projected < ranges:: iterator_t < R2 > , Proj2 >>
    auto mismatch ( R1 && r1, R2 && r2, Pred pred = Pred { } ,
    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 Pred = ranges:: equal_to <> ,
    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    erfordert InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectRelation < Pred, projected < I1, Proj1 > ,
    projected < std:: decay_t < I2 > , Proj2 >>
    auto mismatch ( I1 first1, S1 last1, I2 && first2_, Pred pred = Pred { } ,
    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 Pred = ranges:: equal_to <> ,

    class Proj1 = ranges:: identity , class Proj2 = ranges:: identity >
    erfordert InputIterator < std:: decay_t < I2 >> && ! Range < I2 > &&
    IndirectRelation < Pred, projected < ranges:: iterator_t < R1 > , Proj1 > ,
    projected < std:: decay_t < I2 > , Proj2 >>
    auto mismatch ( R1 && r1, I2 && first2_, Pred pred = Pred { } ,
    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 Paar von Elementen aus zwei Bereichen zurück: einer definiert durch [ first1 , last1 ) und ein anderer definiert durch [ first2 , last2 ) .
    2) Gleich wie (1) , verwendet jedoch 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) Gleich wie (1) , verhält sich jedoch so, als ob first2 ist std:: decay_t < I2 > first2 = std:: forward < I2 > ( first2_ ) ; und last2 ist ranges :: unreachable { }. Der zugrundeliegende Algorithmus erhöht first2 niemals mehr als last1 - first1 Mal.
    4) Gleich wie (3) , verwendet jedoch r1 als ersten Quellbereich, als ob ranges:: begin ( r1 ) als first1 und ranges:: end ( r1 ) als last1 verwendet würde.

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

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

    Inhaltsverzeichnis

    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

    Rückgabewert

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

    Wenn beim Vergleich bis last1 oder last2 , je nachdem was zuerst eintritt, keine Nichtübereinstimmungen gefunden werden, enthält das Paar den End-Iterator und den entsprechenden Iterator aus dem anderen Bereich.

    Komplexität

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

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

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Siehe auch

    		 ermittelt die erste Position, an der sich zwei Bereiche unterscheiden
    (Funktionsschablone & Algorithmus-Funktionsobjekt)
    (C++20)
    		bestimmt, ob zwei Mengen von Elementen gleich sind
    (Funktionsschablone)
    		ermittelt das erste Element, das bestimmte Kriterien erfüllt
    (Funktionsschablone)
    		gibt true zurück, wenn ein Bereich lexikografisch kleiner als ein anderer ist
    (Funktionsschablone)
    		sucht nach einem Bereich von Elementen
    (Funktionsschablone)