Namensräume
Varianten
Aktionen

std::experimental::ranges::search_n

Von cppreference.com
< cpp‎ | experimental‎ | ranges
 
 
 
 
 
template< ForwardIterator I, Sentinel<I> S, class T,

          class Pred = ranges::equal_to<>, class Proj = ranges::identity >
    requires IndirectlyComparable<I, const T*, Pred, Proj>
I search_n( I first, S last, ranges::difference_type_t<I> count,

            const T& value, Pred pred = Pred{}, Proj proj = Proj{} );
(1) (Ranges TS)
template< ForwardRange R, class T, class Pred = ranges::equal_to<>,

          class Proj = ranges::identity >
    requires IndirectlyComparable<ranges::iterator_t<R>, const T*, Pred, Proj>
ranges::safe_iterator_t<R> search_n( R&& r,
                                     ranges::difference_type_t<ranges::iterator_t<R>> count,

                                     const T& value, Pred pred = Pred{}, Proj proj = Proj{} );
(2) (Ranges TS)
1) Durchsucht den Bereich [firstlast) nach der ersten Sequenz von count Elementen, deren projizierte Werte gemäß der Prädikatfunktion pred jeweils gleich dem gegebenen Wert value sind.
2) Dasselbe wie (1), aber verwendet r als Quellbereich, als ob ranges::begin(r) als first und ranges::end(r) als last verwendet würden.

Inhalt

[bearbeiten] Parameter

first, last - der Bereich der zu untersuchenden Elemente
r - der Bereich der zu untersuchenden Elemente
zählt - die Länge der zu durchsuchenden Sequenz
value - Der zu suchende Wert
pred - Das Prädikat, das die projizierten Elemente mit value vergleicht
proj - die Projektion, die auf die Elemente angewendet werden soll

[bearbeiten] Rückgabewert

Iterator auf den Anfang der gefundenen Sequenz im Bereich [firstlast). Wenn keine solche Sequenz gefunden wird, wird ein Iterator zurückgegeben, der gleich last ist.

[bearbeiten] Komplexität

Maximal last - first Anwendungen des Prädikats und der Projektion.

[bearbeiten] Mögliche Implementierung

template<ForwardIterator I, Sentinel<I> S, class T,
         class Pred = ranges::equal_to<>, class Proj = ranges::identity>
    requires IndirectlyComparable<I, const T*, Pred, Proj>
I search_n(I first, S last, ranges::difference_type_t<I> count,
           const T& value, Pred pred = Pred{}, Proj proj = Proj{})
{
    for (; first != last; ++first)
    {
        if (!ranges::invoke(pred, ranges::invoke(proj, *first), value))
            continue;
 
        I candidate = first;
        ranges::difference_type_t<I> cur_count = 0;
 
        while (true)
        {
            ++cur_count;
            if (cur_count == count)
                // success
                return candidate;
 
            ++first;
            if (first == last)
                // exhausted the list
                return first;
 
            if (!ranges::invoke(pred, ranges::invoke(proj, *first), value))
                // too few in a row
                break;
        }
    }
    return first;
}

[bearbeiten] Beispiel

[bearbeiten] Siehe auch

Sucht nach dem ersten Vorkommen einer Anzahl aufeinanderfolgender Kopien eines Elements in einem Bereich
(Funktionstempelat) [edit]
Findet die letzte Sequenz von Elementen in einem bestimmten Bereich
(Funktionsvorlage) [bearbeiten]
Findet das erste Element, das bestimmte Kriterien erfüllt
(Funktionsvorlage) [bearbeiten]
sucht nach einem Bereich von Elementen
(Funktionsvorlage) [bearbeiten]