| Permutation operations |
| | |
| Fold operations |
| | |
|
|
| Operations on uninitialized storage |
| | | |
| Return types |
| | | |
(1)
(since C++23) (until C++26)
template< std::input_iterator I, std::sentinel_for <I> S,
class Proj = std::identity,
class T = std::projected_value_t<I, Proj> >
requires std::indirect_binary_predicate
<ranges::equal_to, std::projected <I, Proj>, const T*>
constexpr bool contains( I first, S last, const T& value, Proj proj = {} );
(since C++26)
(2)
(since C++23) (until C++26)
template< std::forward_iterator I1, std::sentinel_for <I1> S1,
std::forward_iterator I2, std::sentinel_for <I2> S2,
class Pred = ranges::equal_to,
class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable <I1, I2, Pred, Proj1, Proj2>
constexpr bool contains_subrange( I1 first1, S1 last1, I2 first2, S2 last2,
Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {} );
(3)
(since C++23)
template< ranges::forward_range R1, ranges::forward_range R2,
class Pred = ranges::equal_to,
class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable
<ranges::iterator_t <R1>, ranges::iterator_t <R2>,
Pred, Proj1, Proj2>
constexpr bool contains_subrange( R1&& r1, R2&& r2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {} );
(4)
(since C++23)
1,2) Checks whether or not a given range contains the value value.
1) The source range is [first, last).
3) Checks whether or not a given range is a subrange of another range.
3) The first source range is [first1, last1), and the second source range is [first2, last2).
The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:
[edit] Parameters
first, last
-
the iterator-sentinel pair defining the
range of elements to examine
r
-
the range of the elements to examine
value
-
value to compare the elements to
pred
-
predicate to apply to the projected elements
proj
-
projection to apply to the elements
[edit] Return value
1) ranges::find (std::move(first), last, value, proj) != last
3) first2 == last2 || !ranges::search (first1, last1, first2, last2, pred, proj1, proj2).empty()
[edit] Complexity
In C++20, one may implement a contains function with ranges::find (haystack, needle) != ranges::end (haystack) or contains_subrange with !ranges::search (haystack, needle).empty().
ranges::contains_subrange, like ranges::search , and unlike std::search , has no support for searchers (such as std::boyer_moore_searcher ).
[edit] Possible implementation
| contains (1,2)
|
struct __contains_fn
{
template<std::input_iterator I, std::sentinel_for <I> S,
class Proj = std::identity,
class T = std::projected_value_t<I, Proj>>
requires std::indirect_binary_predicate <ranges::equal_to, std::projected <I, Proj>,
const T*>
constexpr bool operator()(I first, S last, const T& value, Proj proj = {}) const
{
return ranges::find (std::move(first), last, value, proj) != last;
}
template<ranges::input_range R,
class Proj = std::identity,
class T = std::projected_value_t<ranges::iterator_t <R>, Proj>>
requires std::indirect_binary_predicate <ranges::equal_to,
std::projected <ranges::iterator_t <R>, Proj>,
const T*>
constexpr bool operator()(R&& r, const T& value, Proj proj = {}) const
{
return ranges::find (std::move(ranges::begin (r)),
ranges::end (r), value, proj) != ranges::end (r);
}
};
inline constexpr __contains_fn contains{}; |
| contains_subrange (3,4)
|
struct __contains_subrange_fn
{
template<std::forward_iterator I1, std::sentinel_for <I1> S1,
std::forward_iterator I2, std::sentinel_for <I2> S2,
class Pred = ranges::equal_to,
class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable <I1, I2, Pred, Proj1, Proj2>
constexpr bool operator()(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
return (first2 == last2) ||
!ranges::search (first1, last1, first2, last2,
pred, proj1, proj2).empty();
}
template<ranges::forward_range R1, ranges::forward_range R2,
class Pred = ranges::equal_to,
class Proj1 = std::identity, class Proj2 = std::identity >
requires std::indirectly_comparable <ranges::iterator_t <R1>,
ranges::iterator_t <R2>, Pred, Proj1, Proj2>
constexpr bool operator()(R1&& r1, R2&& r2, Pred pred = {},
Proj1 proj1 = {}, Proj2 proj2 = {}) const
{
return (first2 == last2) ||
!ranges::search (ranges::begin (r1), ranges::end (r1),
ranges::begin (r2), ranges::end (r2),
pred, proj1, proj2).empty();
}
};
inline constexpr __contains_subrange_fn contains_subrange{}; |
[edit] Example
#include <algorithm>
#include <array>
#include <complex>
namespace ranges = std::ranges;
int main()
{
constexpr auto haystack = std::array {3, 1, 4, 1, 5};
constexpr auto needle = std::array {1, 4, 1};
constexpr auto bodkin = std::array {2, 5, 2};
static_assert
(
ranges::contains(haystack, 4) &&
!ranges::contains(haystack, 6) &&
ranges::contains_subrange(haystack, needle) &&
!ranges::contains_subrange(haystack, bodkin)
);
constexpr std::array <std::complex <double>, 3> nums{{{1, 2}, {3, 4}, {5, 6}}};
#ifdef __cpp_lib_algorithm_default_value_type
static_assert(ranges::contains(nums, {3, 4}));
#else
static_assert(ranges::contains(nums, std::complex <double>{3, 4}));
#endif
}
[edit] See also
finds the first element satisfying specific criteria
(algorithm function object)[edit]
searches for the first occurrence of a range of elements
(algorithm function object)[edit]
determines if an element exists in a partially-ordered range
(algorithm function object)[edit]
returns
true if one sequence is a subsequence of another
(algorithm function object)[edit]
checks if a predicate is
true for all, any or none of the elements in a range
(algorithm function object)[edit]