std::ranges::find_first_of

Definiert in Header `<algorithm>`
Aufrufsignatur
template< std::input_iterator I1, std::sentinel_for<I1> S1, std::forward_iterator I2, std::sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> constexpr I1 find_first_of( I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(1)	(seit C++20)
template< ranges::input_range R1, ranges::forward_range R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> constexpr ranges::borrowed_iterator_t<R1> find_first_of( R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(2)	(seit C++20)
template< /execution-policy/ Ep, std::random_access_iterator I1, std::sized_sentinel_for<I1> S1, std::random_access_iterator I2, std::sized_sentinel_for<I2> S2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2> I1 find_first_of( Ep&& policy, I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(3)	(seit C++26)
template< /execution-policy/ Ep, /sized-random-access-range/ R1, /sized-random-access-range/ R2, class Pred = ranges::equal_to, class Proj1 = std::identity, class Proj2 = std::identity > requires std::indirectly_comparable<ranges::iterator_t<R1>, ranges::iterator_t<R2>, Pred, Proj1, Proj2> ranges::borrowed_iterator_t<R1> find_first_of( Ep&& policy, R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {} );	(4)	(seit C++26)

Für die Definition von /*execution-policy*/ siehe diese Seite; für die Definition von /*sized-random-access-range*/ siehe diese Seite.

Durchsucht den Quellbereich nach einem der Elemente im Zielbereich. Die Elemente (projiziert durch proj1 bzw. proj2) werden mit dem binären Prädikat pred verglichen.

1) Der Quellbereich ist [first1, last1) und der Zielbereich ist [first2, last2).

2) Der Quellbereich ist r1 und der Zielbereich ist r2.

3,4) Gleich wie (1,2), aber ausgeführt gemäß policy.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithmus-Funktionsobjekte (informell als Niebloids bekannt), d.h.:

Explizite Vorlagenargumentlisten können beim Aufruf keiner von ihnen angegeben werden.
Keine von ihnen ist für argumentabhängige Suche sichtbar.
Wenn eine von ihnen durch normale nicht-qualifizierte Suche als Name links vom Funktionsaufrufoperator gefunden wird, wird argumentabhängige Suche unterdrückt.

Parameter

first1, last1	-	das Iterator-Sentinel-Paar, das den Quell-bereich
definiertfirst2, last2	-	das Iterator-Sentinel-Paar, das den Ziel-bereich
definiertr1	-	der Quellbereich
r2	-	der Zielbereich
pred	-	das Prädikat, das auf die (projizierten) Elemente angewendet werden soll
proj1	-	die Projektion, die auf die Elemente im Quellbereich angewendet werden soll
proj2	-	die Projektion, die auf die Elemente im Zielbereich angewendet werden soll
policy	-	die Ausführungsrichtlinie zur Verwendung

Rückgabewert

Iterator auf das erste Element im Quellbereich, das einem Element aus dem Zielbereich entspricht.

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

1,3) last1

2,4) ranges::next(ranges::begin(r1), ranges::end(r1))

Komplexität

Gegeben $\scriptsize N_1$ $N 1$ als ranges::distance(first1, last1) oder ranges::distance(r1), und $\scriptsize N_2$ $N 2$ als ranges::distance(first2, last2) oder ranges::distance(r2):

1,2) Höchstens

N 1 \cdotN 2

Anwendungen von pred und proj.

3,4)

𝓞(N 1 \cdotN 2)

Anwendungen von pred und proj.

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 ausgelöst.
Wenn beim Zugriff auf Objekte über ein Algorithmusargument eine nicht abgefangene Ausnahme ausgelöst wird, wird das Verhalten durch die Ausführungsrichtlinie bestimmt (für Standardrichtlinien wird std::terminate aufgerufen).

Mögliche Implementierung

struct find_first_of_fn
{
    template<std::input_iterator I1, std::sentinel_for<I1> S1,
             std::forward_iterator I2, std::sentinel_for<I2> S2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
        requires std::indirectly_comparable<I1, I2, Pred, Proj1, Proj2>
    constexpr I1 operator()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
                            Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        for (; first1 != last1; ++first1)
            for (auto i = first2; i != last2; ++i)
                if (std::invoke(pred, std::invoke(proj1, *first1), std::invoke(proj2, *i)))
                    return first1;
        return first1;
    }
    
    template<ranges::input_range R1, ranges::forward_range R2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_comparable<ranges::iterator_t<R1>,
                                        ranges::iterator_t<R2>,
                                        Pred, Proj1, Proj2>
    constexpr ranges::borrowed_iterator_t<R1>
        operator()(R1&& r1, R2&& r2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2),
                       ranges::next(ranges::begin(r2), ranges::end(r2)),
                       std::move(pred), std::move(proj1), std::move(proj2));
    }
    
    template<ranges::forward_range R1, ranges::forward_range R2,
             class Pred = ranges::equal_to,
             class Proj1 = std::identity, class Proj2 = std::identity>
    requires std::indirectly_comparable<ranges::iterator_t<R1>,
                                        ranges::iterator_t<R2>,
                                        Pred, Proj1, Proj2>
    constexpr ranges::borrowed_iterator_t<R1>
        operator()(R1&& r1, R2&& r2, Pred pred = {},
                   Proj1 proj1 = {}, Proj2 proj2 = {}) const
    {
        return (*this)(ranges::begin(r1),
                       ranges::next(ranges::begin(r1), ranges::end(r1)),
                       ranges::begin(r2),
                       ranges::next(ranges::begin(r2), ranges::end(r2)),
                       std::move(pred), std::move(proj1), std::move(proj2));
    }
};

inline constexpr find_first_of_fn find_first_of{};

Beispiel

Diesen Code ausführen

#include <algorithm>
#include <iostream>
#include <iterator>

int main()
{
    using std::ranges::find_first_of;
    
    constexpr static auto haystack = {1, 2, 3, 4};
    constexpr static auto needles  = {0, 3, 4, 3};
    
    constexpr auto found1 = find_first_of(haystack.begin(), haystack.end(),
                                          needles.begin(), needles.end());
    static_assert(std::distance(haystack.begin(), found1) == 2);
    
    constexpr auto found2 = find_first_of(haystack, needles);
    static_assert(std::distance(haystack.begin(), found2) == 2);
    
    constexpr static auto negatives = {-6, -3, -4, -3};
    constexpr auto not_found = find_first_of(haystack, negatives);
    static_assert(not_found == haystack.end());
    
    constexpr auto found3 = find_first_of(haystack, negatives,
        [](int x, int y) { return x == -y; }); // uses a binary comparator
    static_assert(std::distance(haystack.begin(), found3) == 2);
    
    struct P { int x, y; };
    constexpr static auto p1 = {P{1, -1}, P{2, -2}, P{3, -3}, P{4, -4}};
    constexpr static auto p2 = {P{5, -5}, P{6, -3}, P{7, -5}, P{8, -3}};
    
    // Compare only P::y data members by projecting them:
    const auto found4 = find_first_of(p1, p2, {}, &P::y, &P::y);
    std::cout << "First equivalent element {" << found4->x << ", " << found4->y
              << "} was found at position " << std::distance(p1.begin(), found4)
              << ".\n";
}

Ausgabe:

First equivalent element {3, -3} was found at position 2.

Siehe auch

find_first_of	sucht nach einem beliebigen Element aus einer Menge (Funktionstemplate)
ranges::adjacent_find (C++20)	findet die ersten beiden benachbarten Elemente, die gleich sind (oder ein gegebenes Prädikat erfüllen) (Algorithmus-Funktionsobjekt)
ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	findet das erste Element, das bestimmte Kriterien erfüllt (Algorithmus-Funktionsobjekt)
ranges::find_end (C++20)	findet die letzte Sequenz von Elementen in einem bestimmten Bereich (Algorithmus-Funktionsobjekt)
ranges::search (C++20)	sucht nach dem ersten Vorkommen eines Bereichs von Elementen (Algorithmus-Funktionsobjekt)
ranges::search_n (C++20)	sucht nach dem ersten Vorkommen einer bestimmten Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich (Algorithmus-Funktionsobjekt)

Compiler-Unterstützung
Freistehend und gehostet
Sprache
Standardbibliothek
Standardbibliothek-Header
Benannte Anforderungen
Feature-Test-Makros (C++20)
Sprachunterstützungsbibliothek
Konzepte-Bibliothek (C++20)
Diagnosebibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogrammbibliothek
Containerbibliothek
Iteratorenbibliothek
Bereichsbibliothek (C++20)
Algorithmusbibliothek
Zeichenkettenbibliothek
Textverarbeitungsbibliothek
Numerikbibliothek
Datums- und Zeitbibliothek
Eingabe-/Ausgabebibliothek
Dateisystembibliothek (C++17)
Nebenläufigkeitsunterstützungsbibliothek (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolindex
Externe Bibliotheken

de.cppreference.net

Namespaces

Variants