| Defined in header <algorithm> | ||
|---|---|---|
template< class ForwardIt, class Size, class T > ForwardIt search_n( ForwardIt first, ForwardIt last, Size count, const T& value ); | (1) | |
template< class ForwardIt, class Size, class T, class BinaryPredicate >
ForwardIt search_n( ForwardIt first, ForwardIt 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.
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:
The signature does not need to have |
| Type requirements | ||
- ForwardIt must meet the requirements of ForwardIterator. | ||
Return value
Iterator to the beginning of the found sequence in the range [first, last). If no such sequence is found, last is returned.
Complexity
At most last - first applications of the predicate.
Possible implementation
| First version |
|---|
template<class ForwardIt, class Size, class T>
ForwardIt search_n(ForwardIt first, ForwardIt last,
Size count, const T& value)
{
for(; first != last; ++first) {
if (!(*first == value)) {
continue;
}
ForwardIt candidate = first;
Size cur_count = 0;
while (true) {
++cur_count;
if (cur_count == count) {
// success
return candidate;
}
++first;
if (first == last) {
// exhausted the list
return last;
}
if (!(*first == value)) {
// too few in a row
break;
}
}
}
return last;
} |
| Second version |
template<class ForwardIt, class Size, class T, class BinaryPredicate>
ForwardIt search_n(ForwardIt first, ForwardIt last,
Size count, const T& value, BinaryPredicate p)
{
for(; first != last; ++first) {
if (!p(*first, value)) {
continue;
}
ForwardIt candidate = first;
Size cur_count = 0;
while (true) {
++cur_count;
if (cur_count == count) {
// success
return candidate;
}
++first;
if (first == last) {
// exhausted the list
return last;
}
if (!p(*first, value)) {
// too few in a row
break;
}
}
}
return last;
} |
Example
#include <iostream>
#include <algorithm>
#include <iterator>
template <class Container, class Size, class T>
bool consecutive_values(const Container& c, Size count, const T& v)
{
return std::search_n(std::begin(c),std::end(c),count,v) != std::end(c);
}
int main()
{
const char sequence[] = "1001010100010101001010101";
std::cout << std::boolalpha;
std::cout << "Has 4 consecutive zeros: "
<< consecutive_values(sequence,4,'0') << '\n';
std::cout << "Has 3 consecutive zeros: "
<< consecutive_values(sequence,3,'0') << '\n';
}Output:
Has 4 consecutive zeros: false Has 3 consecutive zeros: true
See also
| finds the last sequence of elements in a certain range (function template) | |
| (C++11) | finds the first element satisfying specific criteria (function template) |
| searches for a range of elements (function template) | |
| std::experimental::parallel::search_n
(parallelism TS) | parallelized version of std::search_n (function template) |
Please login to continue.