Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
C++
 
Experimentell
 
Bereiche (Ranges)
 
Algorithmen-Bibliothek
Nicht-modifizierende Sequenzoperationen
findfind_iffind_if_not
                              
Modifizierende Sequenzoperationen
                              
Partitionierungsoperationen
Sortieroperationen
Binäre Suchoperationen
Mengenoperationen (auf sortierten Bereichen)
                              
Heapoperationen
Minimum/Maximum-Operationen
Permutationen
 
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{} );
 (1) (Ranges TS)
template< InputRange R, class T, class Proj = ranges::identity >

    requires 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 spezifische 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 die Prädikatfunktion p true zurückgibt (d. h. ranges::invoke(pred, ranges::invoke(proj, *i))) true ist.
5) find_if_not sucht nach einem Element, für dessen projizierten Wert die Prädikatfunktion q false zurückgibt (d. h. ranges::invoke(pred, ranges::invoke(proj, *i))) false ist.
2,4,6) Dasselbe wie (1,3,5), verwendet aber r als Quellbereich, so als würde ranges::begin(r) als first und ranges::end(r) als last verwendet werden.

Ungeachtet der oben gezeigten Deklarationen ist die tatsächliche Anzahl und Reihenfolge der Template-Parameter für Algorithmusdeklarationen nicht spezifiziert. Wenn also explizite Template-Argumente beim Aufruf eines Algorithmus verwendet werden, ist das Programm wahrscheinlich nicht portabel.

Inhalt

[bearbeiten] Parameter

first, last - der Bereich der zu untersuchenden Elemente
r - der Bereich der zu untersuchenden Elemente
value - Der 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

[bearbeiten] Rückgabewert

Iterator auf das erste Element, das die Bedingung erfüllt. Wenn kein solches Element gefunden wird, wird ein Iterator zurückgegeben, der gleich last ist.

[bearbeiten] Komplexität

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

[bearbeiten] 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;
}

[bearbeiten] Beispiel

Dieser Abschnitt ist unvollständig
Grund: kein Beispiel

[bearbeiten] Siehe auch

(C++11)
 Findet das erste Element, das bestimmte Kriterien erfüllt
(Funktionstempelat) [edit]
 Findet die ersten beiden benachbarten Elemente, die gleich sind (oder eine gegebene Bedingung erfüllen)
(Funktionsvorlage) [bearbeiten]
 Findet die letzte Sequenz von Elementen in einem bestimmten Bereich
(Funktionsvorlage) [bearbeiten]
 Sucht nach einem der Elemente aus einer Menge von Elementen
(Funktionsvorlage) [bearbeiten]
 Findet die erste Position, an der sich zwei Bereiche unterscheiden
(Funktionsvorlage) [bearbeiten]
 sucht nach einem Bereich von Elementen
(Funktionsvorlage) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/experimental/ranges/algorithm/find&oldid=155244"