Namespaces
Variants

    std::experimental::ranges:: find, std::experimental::ranges:: find_if, std::experimental::ranges:: find_if_not

    From de.cppreference.net
    C++
    Experimental
    Ranges
    Algorithms library
    Non-modifying sequence operations
    find find_if find_if_not
    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 I, Sentinel < I > S, class T, class Proj = ranges:: identity >

    erfordert IndirectRelation < ranges:: equal_to <> , projected < I, Proj > , const T * >

    I find ( I first, S last, const T & value, Proj proj = Proj { } ) ;
    		(1) (ranges TS)
    template < InputRange R, class T, class Proj = ranges:: identity >

    erfordert IndirectRelation < ranges:: equal_to <> ,
    projected < ranges:: iterator_t < R > , Proj > , const T * >

    ranges:: safe_iterator_t < R > find ( R && r, const T & value, Proj proj = Proj { } ) ;
    		(2) (ranges TS)
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    I find_if ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
    		(3) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

    ranges:: safe_iterator_t < R > find_if ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(4) (ranges TS)
    template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < I, Proj >> Pred >

    I find_if_not ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
    		(5) (ranges TS)
    template < InputRange R, class Proj = ranges:: identity ,

    IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >

    ranges:: safe_iterator_t < R > find_if_not ( R && r, Pred pred, Proj proj = Proj { } ) ;
    		(6) (ranges TS)

    Gibt das erste Element im Bereich [ first , last ) zurück, das bestimmte Kriterien erfüllt:

    1) find sucht nach einem Element, dessen projizierter Wert gleich value ist (d.h., value == ranges:: invoke ( proj, * i ) ).
    3) find_if sucht nach einem Element, für dessen projizierten Wert das Prädikat p true zurückgibt (d.h., ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ) ist true ).
    5) find_if_not sucht nach einem Element, für dessen projizierten Wert das Prädikat q false zurückgibt (d.h., ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ) ist false ).
    2,4,6) Gleich wie (1,3,5) , verwendet jedoch r als Quellbereich, als ob ranges:: begin ( r ) als first und ranges:: end ( r ) als last verwendet würde.

    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.

    Inhalt

    Parameter

    first, last - der Bereich der zu untersuchenden Elemente
    r - der Bereich der zu untersuchenden Elemente
    value - Wert, mit dem die projizierten Elemente verglichen werden
    pred - Prädikat, das auf die projizierten Elemente angewendet wird
    proj - Projektion, die auf die Elemente angewendet wird

    Rückgabewert

    Iterator zum ersten Element, das die Bedingung erfüllt. Falls kein solches Element gefunden wird, gibt es einen Iterator zurück, der gleich ist mit last .

    Komplexität

    Höchstens last - first Anwendungen des Prädikats und der Projektion.

    Mögliche Implementierung

    Erste Version 
    template<InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity>
    requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>, const T*>
I find(I first, S last, const T& value, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(proj, *first) == value)
            break;
    return first;
}
    Zweite Version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
I find_if(I first, S last, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *first)))
            break;
    return first;
}
    Dritte Version 
    template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
I find_if_not(I first, S last, Pred pred, Proj proj = Proj{})
{
    for (; first != last; ++first)
        if (!ranges::invoke(pred, ranges::invoke(proj, *first)))
            break;
    return first;
}

    Beispiel

    Dieser Abschnitt ist unvollständig
    Grund: Kein Beispiel

    Siehe auch

    (C++11)
    		 findet das erste Element, das bestimmte Kriterien erfüllt
    (Funktionstemplate & Algorithmus-Funktionsobjekt)
    (C++20)(C++20)(C++20)
    		findet die ersten beiden benachbarten Elemente, die gleich sind (oder ein gegebenes Prädikat erfüllen)
    (Funktionstemplate)
    		findet die letzte Folge von Elementen in einem bestimmten Bereich
    (Funktionstemplate)
    		sucht nach einem beliebigen Element aus einer Menge
    (Funktionstemplate)
    		findet die erste Position, an der sich zwei Bereiche unterscheiden
    (Funktionstemplate)
    		sucht nach einem Bereich von Elementen
    (Funktionstemplate)