std:: adjacent_find

Durchsucht den Bereich [ first , last ) nach zwei aufeinanderfolgenden gleichen Elementen.

Parameter

Rückgabewert

Ein Iterator zum ersten des ersten Paars identischer Elemente, also der erste Iterator it für den gilt * it == * ( it + 1 ) für (1,2) oder p ( * it, * ( it + 1 ) ) ! = false für (3,4) .

Wenn keine solchen Elemente gefunden werden, last wird zurückgegeben.

Komplexität

Gegeben sei result als Rückgabewert von adjacent_find , \(\scriptsize M\) M als std:: distance ( first, result ) und \(\scriptsize N\) N als std:: distance ( first, last ) :

Exceptions

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

• Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

Mögliche Implementierung

template<class ForwardIt>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last)
{
    if (first == last)
        return last;
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first)
        if (*first == *next)
            return first;
    return last;
}

template<class ForwardIt, class BinaryPred>
ForwardIt adjacent_find(ForwardIt first, ForwardIt last, BinaryPred p)
{
    if (first == last)
        return last;
    ForwardIt next = first;
    ++next;
    for (; next != last; ++next, ++first)
        if (p(*first, *next))
            return first;
    return last;
}

`-Tags C++-Code enthält und gemäß den Anweisungen nicht übersetzt werden soll, wurde nur die strukturelle Übersetzung der HTML-Elemente durchgeführt. Die Funktionsnamen und C++-spezifischen Begriffe (wie `template`, `class`, `ForwardIt` etc.) bleiben unverändert, wie gefordert.

Beispiel

#include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
    std::vector<int> v1{0, 1, 2, 3, 40, 40, 41, 41, 5};
    auto i1 = std::adjacent_find(v1.begin(), v1.end());
    if (i1 == v1.end())
        std::cout << "Keine benachbarten übereinstimmenden Elemente\n";
    else
        std::cout << "Das erste benachbarte Paar gleicher Elemente befindet sich an Position "
                  << std::distance(v1.begin(), i1) << ", *i1 = "
                  << *i1 << '\n';
    auto i2 = std::adjacent_find(v1.begin(), v1.end(), std::greater<int>());
    if (i2 == v1.end())
        std::cout << "Der gesamte Vektor ist in aufsteigender Reihenfolge sortiert\n";
    else
        std::cout << "Das letzte Element in der nicht-absteigenden Teilfolge befindet sich an Position "
                  << std::distance(v1.begin(), i2) << ", *i2 = " << *i2 << '\n';
}

Das erste benachbarte Paar gleicher Elemente befindet sich an Position 4, *i1 = 40
Das letzte Element in der nicht-absteigenden Teilfolge befindet sich an Position 7, *i2 = 41

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch