std::search_n

From Cppreference

Jump to: navigation, search
Defined in header <algorithm>

template< class ForwardIterator, class Size, class T >

ForwardIterator1 search_n( ForwardIterator first, ForwardIterator last,

                           Size count, const T& value );
(1)
template< class ForwardIterator, class Size, class T, class BinaryPredicate >

ForwardIterator1 search_n( ForwardIterator first, ForwardIterator last,

                           Size count, const T& value, BinaryPredicate p );
(2)

Searches the range [first, last) for the first sequence of count identical elements, each equal to the given value value. The first version uses operator== to compare the elements, the second version uses the given binary predicate p.

Contents

Parameters

first, last - the range of elements to examine
count - the length of the sequence to search for
value - the value of the elements to search for
p - binary predicate which returns ​true if the elements should be treated as equal.

The signature of the predicate function should be equivalent to the following:

bool pred(const Type1 &a, const Type2 &b);

The signature does not need to have const &, but the function must not modify the objects passed to it.
The type ​Type1​ must be such that an object of type ​ForwardIterator1​ can be dereferenced and then implicitly converted to ​Type1​. The type ​Type2​ must be such that an object of type ​T​ can be implicitly converted to ​Type2​.

Return value

iterator to the beginning of the found sequence in the range [first, last). If no such sequence is found, last is returned.

Equivalent function

First version:
template<class ForwardIterator, class Size, class T>
ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
                          Size count, const T& value)
{
    Size curr_count = 0;
    ForwardIterator result, t_last = first;
    std::advance(t_last, std::distance(first, last) - count + 1);
 
    for (; first != t_last; first++) {
        curr_count = 0;
        result = first;
        while (*first == value) {
            curr_count++;
            if (curr_count == count) {
                return result;
            }
            ++first;
        }
    }
    return last;
}
Second version:
template<class ForwardIterator, class Size, class T, class BinaryPredicate>
ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
                          Size count, const T& value, BinaryPredicate p)
{
    Size curr_count = 0;
    ForwardIterator result, t_last = first;
    std::advance(t_last, std::distance(first, last) - count + 1);
 
    for (; first != t_last; first++) {
        curr_count = 0;
        result = first;
        while (p(*first == value)) {
            curr_count++;
            if (curr_count == count) {
                return result;
            }
            ++first;
        }
    }
    return last;
}

Example

Complexity

linear in the distance between first and last

See also

find_end
finds the last sequence of elements in a certain range
(function template)
find
find_if
find_if_not


(C++0x)
finds the first element satisfying specific criteria
(function template)
search
searches for a range of elements
(function template)
Personal tools
Namespaces
Variants
Actions
Navigation
Toolbox
In other languages