Namespaces
Variants

std::experimental::ranges:: mismatch

From 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

findet die erste Position, an der zwei Bereiche sich unterscheiden
(Funktions-Template)
bestimmt, ob zwei Elementgruppen identisch sind
(Funktions-Template)
findet das erste Element, das spezifische Kriterien erfüllt
(Funktions-Template)
gibt true zurück, falls ein Bereich lexikographisch kleiner als ein anderer ist
(Funktions-Template)
sucht nach einem Bereich von Elementen
(Funktions-Template)