Namespaces
Variants

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

From 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.

Inhaltsverzeichnis

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
(Funktions-Template)
findet die ersten zwei benachbarten Elemente, die gleich sind (oder ein gegebenes Prädikat erfüllen)
(Funktions-Template)
findet die letzte Sequenz von Elementen in einem bestimmten Bereich
(Funktions-Template)
sucht nach einem beliebigen Element aus einer Menge von Elementen
(Funktions-Template)
findet die erste Position, an der zwei Bereiche sich unterscheiden
(Funktions-Template)
sucht nach einem Bereich von Elementen
(Funktions-Template)