W3cubDocs

/C++

std::search

Defined in header `<algorithm>`
template< class ForwardIt1, class ForwardIt2 > ForwardIt1 search( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );	(1)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2 > ForwardIt1 search( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last );	(2)	(since C++17)
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 search( ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );	(3)
template< class ExecutionPolicy, class ForwardIt1, class ForwardIt2, class BinaryPredicate > ForwardIt1 search( ExecutionPolicy&& policy, ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p );	(4)	(since C++17)
template<class ForwardIterator, class Searcher> ForwardIterator search( ForwardIterator first, ForwardIterator last, const Searcher& searcher );	(5)	(since C++17)

1-4) Searches for the first occurrence of the subsequence of elements [s_first, s_last) in the range [first, last - (s_last - s_first)).

1) Elements are compared using operator==.

3) Elements are compared using the given binary predicate p.

2,4) Same as (1,3), but executed according to policy. These overloads do not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true

5) Searches the sequence [first, last) for the pattern specified in the constructor of searcher. Effectively executes return searcher(first, last).first;. Searcher need not be CopyConstructible.

The standard library provides the following searchers:

default_searcher (C++17)	standard C++ library search algorithm implementation (class template)
boyer_moore_searcher (C++17)	Boyer-Moore search algorithm implementation (class template)
boyer_moore_horspool_searcher (C++17)	Boyer-Moore-Horspool search algorithm implementation (class template)

(since C++17)

Parameters

first, last	-	the range of elements to examine
s_first, s_last	-	the range of elements to search for
policy	-	the execution policy to use. See execution policy for details.
searcher	-	the searcher encapsulating the search algorithm and the pattern to look 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 types `Type1` and `Type2` must be such that objects of types `ForwardIt1` and `ForwardIt2` can be dereferenced and then implicitly converted to `Type1` and `Type2` respectively.
Type requirements
- `ForwardIt1, ForwardIt2` must meet the requirements of `ForwardIterator`.
- `Searcher` must meet the requirements of `Searcher`.

Return value

1-4) Iterator to the beginning of first subsequence [s_first, s_last) in the range [first, last - (s_last - s_first)). If no such subsequence is found, last is returned.
If [s_first, s_last) is empty, first is returned. (since C++11)

5) Returns the result of searcher.operator(), that is, an iterator to the location at which the substring is found or a copy of last if it was not found.

Complexity

1-4) At most S*N comparisons where S = std::distance(s_first, s_last) and N = std::distance(first, last).

5) Depends on the searcher

Exceptions

The overloads with a template parameter named ExecutionPolicy report errors as follows:

If execution of a function invoked as part of the algorithm throws an exception, std::terminate is called.
If the algorithm fails to allocate memory, std::bad_alloc is thrown.

Possible implementation

First version
template<class ForwardIt1, class ForwardIt2> ForwardIt1 search(ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last) { for (; ; ++first) { ForwardIt1 it = first; for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) { if (s_it == s_last) { return first; } if (it == last) { return last; } if (!(it == s_it)) { break; } } } }
Second version
template<class ForwardIt1, class ForwardIt2, class BinaryPredicate> ForwardIt1 search(ForwardIt1 first, ForwardIt1 last, ForwardIt2 s_first, ForwardIt2 s_last, BinaryPredicate p) { for (; ; ++first) { ForwardIt1 it = first; for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) { if (s_it == s_last) { return first; } if (it == last) { return last; } if (!p(it, s_it)) { break; } } } }

First version

template<class ForwardIt1, class ForwardIt2>
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                        ForwardIt2 s_first, ForwardIt2 s_last)
{
    for (; ; ++first) {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) {
            if (s_it == s_last) {
                return first;
            }
            if (it == last) {
                return last;
            }
            if (!(*it == *s_it)) {
                break;
            }
        }
    }
}

Second version

template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
                        ForwardIt2 s_first, ForwardIt2 s_last, 
                        BinaryPredicate p)
{
    for (; ; ++first) {
        ForwardIt1 it = first;
        for (ForwardIt2 s_it = s_first; ; ++it, ++s_it) {
            if (s_it == s_last) {
                return first;
            }
            if (it == last) {
                return last;
            }
            if (!p(*it, *s_it)) {
                break;
            }
        }
    }
}

Example

#include <string>
#include <algorithm>
#include <iostream>
#include <vector>
 
template<typename Container>
bool in_quote(const Container& cont, const std::string& s)
{
    return std::search(cont.begin(), cont.end(), s.begin(), s.end()) != cont.end();
}
 
int main()
{
    std::string str = "why waste time learning, when ignorance is instantaneous?";
    // str.find() can be used as well
    std::cout << std::boolalpha << in_quote(str, "learning") << '\n'
                                << in_quote(str, "lemming")  << '\n';
 
    std::vector<char> vec(str.begin(), str.end());
    std::cout << std::boolalpha << in_quote(vec, "learning") << '\n'
                                << in_quote(vec, "lemming")  << '\n';
 
    // The C++17 overload demo:
    std::string in = "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
                     " sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
    std::string needle = "pisci";
    auto it = std::search(in.begin(), in.end(),
                   std::make_boyer_moore_searcher(
                       needle.begin(), needle.end()));
    if(it != in.end())
        std::cout << "The string " << needle << " found at offset "
                  << it - in.begin() << '\n';
    else
        std::cout << "The string " << needle << " not found\n";
}

Output:

true
false
true
false
The string pisci found at offset 43

find_end	finds the last sequence of elements in a certain range (function template)
includes	returns true if one set is a subset of another (function template)
equal	determines if two sets of elements are the same (function template)
findfind_iffind_if_not (C++11)	finds the first element satisfying specific criteria (function template)
lexicographical_compare	returns true if one range is lexicographically less than another (function template)
mismatch	finds the first position where two ranges differ (function template)
search_n	searches for a number consecutive copies of an element in a range (function template)
default_searcher (C++17)	standard C++ library search algorithm implementation (class template)
boyer_moore_searcher (C++17)	Boyer-Moore search algorithm implementation (class template)
boyer_moore_horspool_searcher (C++17)	Boyer-Moore-Horspool search algorithm implementation (class template)
std::experimental::parallel::search (parallelism TS)	parallelized version of `std::search` (function template)