std::find_end
From Cppreference
| Defined in header
<algorithm> | ||
| template< class ForwardIterator1, class ForwardIterator2 >
ForwardIterator1 find_end( ForwardIterator1 first, ForwardIterator1 last, | (1) | |
| template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
ForwardIterator1 find_end( ForwardIterator1 first, ForwardIterator1 last, | (2) | |
Searches for the last subsequence of elements [s_first, s_last) in the range [first, last). 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 | |||||||||
| s_first, s_last | - | the range of 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 const &, but the function must not modify the objects passed to it. | |||||||||
Return value
iterator to the beginning of last subsequence [s_first, s_last) in range [first, last). If no such subsequence is found, last is returned.
Complexity
does at most S*(N-S+1) comparisons where S = distance(s_first, s_last) and N = distance(first, last).
Equivalent function
| First version: |
|---|
template<class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_end(ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 s_first, ForwardIterator2 s_last) { ForwardIterator1 result = last; while (1) { ForwardIterator1 new_result = std::search(first, last, s_first, s_last); result = new_result; if (result == last) { return result; } first = result; ++first; } } |
| Second version: |
template<class ForwardIterator1, class ForwardIterator2> ForwardIterator1 find_end(ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 s_first, ForwardIterator2 s_last, BinaryPredicate p) { ForwardIterator1 result = last; while (1) { ForwardIterator1 new_result = std::search(first, last, s_first, s_last, p); result = new_result; if( result == last ) { return result; } first = result; ++first; } } |
Example
The following code uses find_end() to search for two different sequences of numbers. The the first chunk of code, the last occurence of “1 2 3” is found. In the second chunk of code, the sequence that is being searched for is not found:
#include <algorithm> #include <iostream> int main() { int nums[] = { 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4 }; int* result; int end = 11; int target1[] = { 1, 2, 3 }; result = std::find_end(nums, nums + end, target1, target1 + 3); if (*result == nums[end]) { std::cout << "subsequence { 1, 2, 3 } not found"; } else { std::cout << "last subsequence is at: " << result - nums; } return 0; }
Output:
last subsequence is at: 8
See also
| finds two identical (or some other relationship) items adjacent to each other (function template) | ||
| finds the first element satisfying specific criteria (function template) | ||
| searches for any one of a set of elements (function template) | ||
| searches for N consecutive copies of an element in some range (function template) | ||
