Namespaces
Variants

    std::mismatch

    Von de.cppreference.net
     
    C++
     
    Algorithmenbibliothek
    Eingeschränkte Algorithmen und Algorithmen auf Bereichen (C++20)
    Eingeschränkte Algorithmen, z. B. ranges::copy, ranges::sort, ...
    Nicht modifizierende Sequenzoperationen    
    Stapeloperationen
    (C++17)
    Suchoperationen
    Modifizierende Sequenzoperationen
    Kopieroperationen
    (C++11)
    (C++11)
    (C++11)
    Tauschoperationen
    Transformationsoperationen
    Erzeugungsoperationen
    Entfernungsoperationen
    Reihenfolgeändernde Operationen
    (bis C++17)(C++11)
    (C++20)(C++20)
    Stichprobenoperationen
    (C++17)

    Sortier- und verwandte Operationen
    Partitionierungsoperationen
    (C++11)    
    (C++11)

    Sortieroperationen
    Binäre Suchoperationen
    (auf partitionierten Bereichen)
    Mengenoperationen (auf sortierten Bereichen)
    Mischoperationen (auf sortierten Bereichen)
    Haufenoperationen
    Minimum/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     
    Definiert in Header <algorithm> 
    template< class InputIt1, class InputIt2 >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2 );
    		(1) (constexpr seit C++20) 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2 );
    		(2) (seit C++17) 
    template< class InputIt1, class InputIt2, class BinaryPred >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, BinaryPred p );
    		(3) (constexpr seit C++20) 
    template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryPred >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2, BinaryPred p );
    		(4) (seit C++17) 
    template< class InputIt1, class InputIt2 >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2 );
    		(5) (seit C++14)
    (constexpr seit C++20)    		 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2, ForwardIt2 last2 );
    		(6) (seit C++17) 
    template< class InputIt1, class InputIt2, class BinaryPred >
std::pair<InputIt1, InputIt2>
    mismatch( InputIt1 first1, InputIt1 last1,
              InputIt2 first2, InputIt2 last2, BinaryPred p );
    		(7) (seit C++14)
    (constexpr seit C++20)    		 
    template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryPred >
std::pair<ForwardIt1, ForwardIt2>
    mismatch( ExecutionPolicy&& policy,
              ForwardIt1 first1, ForwardIt1 last1,
              ForwardIt2 first2, ForwardIt2 last2, BinaryPred p );
    		(8) (seit C++17)

    Gibt ein Paar von Iteratoren zum ersten nicht übereinstimmenden Elementpaar aus [first1, last1) und einem Bereich beginnend bei first2 zurück:

    • Für die Überladungen (1-4) hat der zweite Bereich std::distance(first1, last1) Elemente.
    • Für die Überladungen (5-8) ist der zweite Bereich [first2, last2).
    • Wenn std::distance(first1, last1) und std::distance(first2, last2) unterschiedlich sind, endet der Vergleich, wenn last1 oder last2 erreicht wird.
    1,5) Elemente werden mit operator== verglichen.
    3,7) Elemente werden mit dem gegebenen binären Prädikat p verglichen.
    2,4,6,8) Wie (1,3,5,7), aber ausgeführt gemäß policy.
    Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn der Wert des folgenden Ausdrucks true ist:

    std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>

    		(bis C++20)

    std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>

    		(seit C++20)

    Parameter

    first1, last1 - das Paar von Iteratoren, das den ersten Bereich der zu vergleichenden Elemente definiert
    first2, last2 - das Paar von Iteratoren, das den zweiten Bereich der zu vergleichenden Elemente definiert
    policy - die zu verwendende Ausführungsstrategie
    p - binäres Prädikat, das ​true zurückgibt, wenn die Elemente als gleich behandelt werden sollen.

    Die Signatur der Prädikatfunktion sollte wie folgt aussehen:

    bool pred(const Type1 &a, const Type2 &b);

    Die Signatur muss nicht const & enthalten, die Funktion darf jedoch die ihr übergebenen Objekte nicht verändern und muss in der Lage sein, alle Werte des Typs (möglicherweise const) Type1 und Type2 unabhängig von der Werte-Kategorie zu akzeptieren (daher ist Type1 & nicht erlaubt, ebenso wenig wie Type1 außer wenn für Type1 eine Verschiebung gleich einer Kopie ist(seit C++11)).
    Die Typen Type1 und Type2 müssen so beschaffen sein, dass Objekte der Typen InputIt1 und InputIt2 dereferenziert und dann implizit in Type1 bzw. Type2 konvertiert werden können. ​

    Typanforderungen
    -
    InputIt1 muss die Anforderungen von LegacyInputIterator erfüllen.
    -
    InputIt2 muss die Anforderungen von LegacyInputIterator erfüllen.
    -
    ForwardIt1 muss die Anforderungen von LegacyForwardIterator erfüllen.
    -
    ForwardIt2 muss die Anforderungen von LegacyForwardIterator erfüllen.
    -
    BinaryPred muss die Anforderungen von BinaryPredicate erfüllen.

    Rückgabewert

    std::pair mit Iteratoren auf die ersten zwei nicht gleichen Elemente.

    Wenn last1 erreicht ist, ist der zweite Iterator im Paar der std::distance(first1, last1)-te Iterator nach first2.

    Für die Überladungen (5-8), wenn last2 erreicht ist, ist der erste Iterator im Paar der std::distance(first2, last2)-te Iterator nach first1.

    Komplexität

    Sei N1 als std::distance(first1, last1) und N2 als std::distance(first2, last2):

    1,2) Höchstens N1 Vergleiche mit operator==.
    3,4) Höchstens N1 Anwendungen des Prädikats p.
    5,6) Höchstens min(N1,N2) Vergleiche mit operator==.
    7,8) Höchstens min(N1,N2) Anwendungen des Prädikats p.

    Ausnahmen

    Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

    • Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Ausnahme auslöst und ExecutionPolicy eine der Standardstrategien ist, wird std::terminate aufgerufen. Für jedes andere ExecutionPolicy ist das Verhalten implementationsdefiniert.
    • Wenn der Algorithmus keinen Speicher zuweisen kann, wird std::bad_alloc ausgelöst.

    Mögliche Implementierung

    mismatch (1) 
    template<class InputIt1, class InputIt2>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2)
{
    while (first1 != last1 && *first1 == *first2)
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}
    mismatch (3) 
    template<class InputIt1, class InputIt2, class BinaryPred>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, BinaryPred p)
{
    while (first1 != last1 && p(*first1, *first2))
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}
    mismatch (5) 
    template<class InputIt1, class InputIt2>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2)
{
    while (first1 != last1 && first2 != last2 && *first1 == *first2)
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}
    mismatch (7) 
    template<class InputIt1, class InputIt2, class BinaryPred>
std::pair<InputIt1, InputIt2>
    mismatch(InputIt1 first1, InputIt1 last1,
             InputIt2 first2, InputIt2 last2, BinaryPred p)
{
    while (first1 != last1 && first2 != last2 && p(*first1, *first2))
        ++first1, ++first2;
    
    return std::make_pair(first1, first2);
}

    Beispiel

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

    Diesen Code ausführen
    #include <algorithm>
#include <iostream>
#include <string>

std::string mirror_ends(const std::string& in)
{
    return std::string(in.begin(),
                       std::mismatch(in.begin(), in.end(), in.rbegin()).first);
}

int main()
{
    std::cout << mirror_ends("abXYZba") << '\n'
              << mirror_ends("abca") << '\n'
              << mirror_ends("aba") << '\n';
}

    Ausgabe: 

    ab
a
aba

    Siehe auch

    		 bestimmt, ob zwei Mengen von Elementen gleich sind
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++11)
    		 findet das erste Element, das bestimmte Kriterien erfüllt
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)(C++20)
    		vergleicht zwei Bereiche lexikografisch
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    		sucht nach dem ersten Vorkommen eines Bereichs von Elementen
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)
    (C++20)
    		 findet die erste Position, an der sich zwei Bereiche unterscheiden
    (Algorithmus-Funktionsobjekt)