Defined in header <algorithm> | ||
|---|---|---|
| (1) | ||
template< class ForwardIt1, class ForwardIt2 >
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
| (until C++20) | |
template< class ForwardIt1, class ForwardIt2 >
constexpr ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last );
| (since C++20) | |
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) |
| (3) | ||
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPredicate p );
| (until C++20) | |
template< class ForwardIt1, class ForwardIt2, class BinaryPredicate >
constexpr ForwardIt1 search( ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPredicate p );
| (since C++20) | |
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) |
| (5) | ||
template< class ForwardIt, class Searcher >
ForwardIt search( ForwardIt first, ForwardIt last,
const Searcher& searcher );
| (since C++17) (until C++20) | |
template< class ForwardIt, class Searcher >
constexpr ForwardIt search( ForwardIt first, ForwardIt last,
const Searcher& searcher );
| (since C++20) |
[s_first, s_last) in the range [first, last).operator==.p.policy. These overloads do not participate in overload resolution unless |
| (until C++20) |
|
| (since C++20) |
[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:
| (since C++17) |
| 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:
While the signature does not need to have |
| Type requirements | ||
-ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator. |
||
-Searcher must meet the requirements of Searcher. |
||
[s_first, s_last) in the range [first, last). If no such occurrence is found, last is returned.[s_first, s_last) is empty, first is returned. (since C++11)
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.S * N comparisons where S = std::distance(s_first, s_last) and N = std::distance(first, last).The overloads with a template parameter named ExecutionPolicy report errors as follows:
ExecutionPolicy is one of the standard policies, std::terminate is called. For any other ExecutionPolicy, the behavior is implementation-defined. std::bad_alloc is thrown. | search (1) |
|---|
template<class ForwardIt1, class ForwardIt2>
constexpr ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last)
{
while (true)
{
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;
}
++first;
}
} |
| search (3) |
template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
constexpr ForwardIt1 search(ForwardIt1 first, ForwardIt1 last,
ForwardIt2 s_first, ForwardIt2 s_last,
BinaryPredicate p)
{
while (true)
{
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;
}
} |
#include <algorithm>
#include <functional>
#include <iomanip>
#include <iostream>
#include <string_view>
#include <vector>
using namespace std::literals;
bool contains(const auto& cont, std::string_view s)
{
// str.find() (or str.contains(), since C++23) can be used as well
return std::search(cont.begin(), cont.end(), s.begin(), s.end()) != cont.end();
}
int main()
{
const auto str {"why waste time learning, when ignorance is instantaneous?"sv};
std::cout << std::boolalpha
<< contains(str, "learning") << '\n' // true
<< contains(str, "lemming") << '\n'; // false
const std::vector vec(str.begin(), str.end());
std::cout << contains(vec, "learning") << '\n' // true
<< contains(vec, "leaning") << '\n'; // false
// The C++17 overload with searchers demo:
constexpr auto haystack
{
"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed "
"do eiusmod tempor incididunt ut labore et dolore magna aliqua"sv
};
for (const auto needle : {"pisci"sv, "Pisci"sv})
{
const std::boyer_moore_searcher searcher(needle.begin(), needle.end());
const auto it = std::search(haystack.begin(), haystack.end(), searcher);
std::cout << "The string " << std::quoted(needle) << ' ';
if (it == haystack.end())
std::cout << "not found\n";
else
std::cout << "found at offset " << it - haystack.begin() << '\n';
}
}Output:
true false true false The string "pisci" found at offset 43 The string "Pisci" not found
| finds the last sequence of elements in a certain range (function template) |
|
returns true if one sequence is a subsequence of another (function template) |
|
| determines if two sets of elements are the same (function template) |
|
|
(C++11) | finds the first element satisfying specific criteria (function template) |
returns true if one range is lexicographically less than another (function template) |
|
| finds the first position where two ranges differ (function template) |
|
| searches a range for a number of consecutive copies of an element (function template) |
|
|
(C++17) | standard C++ library search algorithm implementation (class template) |
|
(C++17) | Boyer-Moore search algorithm implementation (class template) |
|
(C++17) | Boyer-Moore-Horspool search algorithm implementation (class template) |
|
(C++20) | searches for a range of elements (niebloid) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/algorithm/search