Namespaces
Variants

    std::find_first_of

    Von de.cppreference.net
     
    C++
     
    Algorithmusbibliothek
    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änderungsoperationen
    (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)
    Heap-Operationen
    Minimum-/Maximum-Operationen
    (C++11)
    (C++17)
    Lexikografische Vergleichsoperationen
    (C++20)
    Permutationsoperationen


     
    Definiert in Header <algorithm> 
    template< class InputIt, class ForwardIt >
InputIt find_first_of( InputIt first1, InputIt last1,
                       ForwardIt first2, ForwardIt last2 );
    		(1) (constexpr seit C++20) 
    template< class InputIt, class ForwardIt, class BinaryPred >
InputIt find_first_of( InputIt first1, InputIt last1,
                       ForwardIt first2, ForwardIt last2,
                       BinaryPred p );
    		(2) (constexpr seit C++20) 
    template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 >
ForwardIt1 find_first_of( ExecutionPolicy&& policy,
                          ForwardIt1 first1, ForwardIt1 last1,
                          ForwardIt2 first2, ForwardIt2 last2 );
    		(3) (seit C++17) 
    template< class ExecutionPolicy,
          class ForwardIt1, class ForwardIt2, class BinaryPred >
ForwardIt1 find_first_of( ExecutionPolicy&& policy,
                          ForwardIt1 first1, ForwardIt last1,
                          ForwardIt2 first2, ForwardIt2 last2,
                          BinaryPred p );
    		(4) (seit C++17)

    Durchsucht den Quellbereich [first1, last1) nach einem der Elemente im Zielbereich [first2, last2).

    1) Elemente werden mit operator== verglichen.
    2) Elemente werden mit dem angegebenen binären Prädikat p verglichen.
    3,4) Wie (1,2), 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 Quellbereich
    first2, last2 - das Paar von Iteratoren, das den Zielbereich
    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 äquivalent sein:

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

    Während die Signatur kein const & haben muss, darf die Funktion die ihr übergebenen Objekte nicht ändern und muss in der Lage sein, alle Werte des Typs (möglicherweise const) Type1 und Type2 unabhängig von der Wertkategorie zu akzeptieren (daher ist Type1 & nicht erlaubt, noch Type1 es sei denn, für Type1 ist eine Bewegung äquivalent zu einer Kopie(seit C++11)).
    Die Typen Type1 und Type2 müssen so sein, dass Objekte der Typen ForwardIt1 und ForwardIt2 dereferenziert und dann implizit in Type1 bzw. Type2 konvertiert werden können. ​

    policy - die zu verwendende Ausführungsrichtlinie
    Typanforderungen
    -
    InputIt muss die Anforderungen von LegacyInputIterator erfüllen.
    -
    ForwardIt muss die Anforderungen von LegacyForwardIterator 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

    Iterator zum ersten Element im Quellbereich, das mit einem Element aus dem Zielbereich übereinstimmt.

    Wenn der Zielbereich leer ist oder kein solches Element gefunden wird, wird last1 zurückgegeben.

    Komplexität

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

    1) Höchstens N1⋅N2 Vergleiche mit operator==.
    2) Höchstens N1⋅N2 Anwendungen von p.
    3) 𝒪(N1⋅N2) Vergleiche mit operator==.
    4) 𝒪(N1⋅N2) Anwendungen von p.

    Ausnahmen

    3,4) Während des Ausführungsprozesses:
    • Wenn die für die Parallelisierung erforderlichen temporären Speicherressourcen nicht verfügbar sind, wird std::bad_alloc geworfen.
    • Wenn eine nicht gefangene Ausnahme beim Zugriff auf Objekte über ein Algorithmusargument geworfen wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien wird std::terminate aufgerufen).

    Mögliche Implementierung

    find_first_of (1) 
    template<class InputIt, class ForwardIt>
InputIt find_first_of(InputIt first1, InputIt last1,
                      ForwardIt first2, ForwardIt last2)
{
    for (; first1 != last1; ++first1)
        for (ForwardIt it = first2; it != last2; ++it)
            if (*first1 == *it)
                return first1;
    return last1;
}
    find_first_of (2) 
    template<class InputIt, class ForwardIt, class BinaryPred>
InputIt find_first_of(InputIt first1, InputIt last1,
                      ForwardIt first2, ForwardIt last2,
                      BinaryPred p)
{
    for (; first1 != last1; ++first1)
        for (ForwardIt it = first2; it != last2; ++it)
            if (p(*first1, *it))
                return first1;
    return last1;
}

    Beispiel

    Der folgende Code sucht nach einer der angegebenen Ganzzahlen in einem Vektor von Ganzzahlen:

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

auto print_sequence = [](const auto id, const auto& seq, int pos = -1)
{
    std::cout << id << "{ ";
    for (int i{}; const auto& e : seq)
    {
        const bool mark{i == pos};
        std::cout << (i++ ? ", " : "");
        std::cout << (mark ? "[ " : "") << e << (mark ? " ]" : "");
    }
    std::cout << " }\n";
};

int main()
{
    const std::vector<int> v{0, 2, 3, 25, 5};
    const auto t1 = {19, 10, 3, 4};
    const auto t2 = {1, 6, 7, 9};
    
    auto find_any_of = [](const auto& v, const auto& t)
    {
        const auto result = std::find_first_of(v.begin(), v.end(),
                                               t.begin(), t.end());
        if (result == v.end())
        {
            std::cout << "No elements of v are equal to any element of ";
            print_sequence("t = ", t);
            print_sequence("v = ", v);
        }
        else
        {
            const auto pos = std::distance(v.begin(), result);
            std::cout << "Found a match (" << *result << ") at position " << pos;
            print_sequence(", where t = ", t);
            print_sequence("v = ", v, pos);
        }
    };
    
    find_any_of(v, t1);
    find_any_of(v, t2);
}

    Ausgabe: 

    Found a match (3) at position 2, where t = { 19, 10, 3, 4 }
v = { 0, 2, [ 3 ], 25, 5 }
No elements of v are equal to any element of t = { 1, 6, 7, 9 }
v = { 0, 2, 3, 25, 5 }

    Fehlerberichte

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

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 576 C++98 first1 und last1 mussten LegacyForwardIterators sein sie müssen nur LegacyInputIterators sein
    LWG 1205 C++98 der Rückgabewert war unklar, wenn der Zielbereich leer ist gibt in diesem Fall last1 zurück

    Siehe auch

    (C++20)
    		 sucht nach einem beliebigen Element aus einer Menge von Elementen
    (Algorithmusfunktionsobjekt)
    (C++11)
    		 findet das erste Element, das bestimmte Kriterien erfüllt
    (Funktionsschablone & Algorithmusfunktionsobjekt)
    (C++20)(C++20)(C++20)