std::ranges::contains, std::ranges::contains_subrange - cppreference.com (original) (raw)

1,2) Checks whether or not a given range contains the value value.

1. The source range is [first, last).

2. 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:

• Explicit template argument lists cannot be specified when calling any of them.
• None of them are visible to argument-dependent lookup.
• When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

Contents

• 1 Parameters
• 2 Return value
• 3 Complexity
• 4 Notes
• 5 Possible implementation
• 6 Example
• 7 See also

[edit] Parameters

[edit] Return value

1. ranges::find(std::move(first), last, value, proj) != last

2. first2 == last2 || (first1, last1, first2, last2, pred, proj1, proj2).empty()

[edit] Complexity

[edit] Notes

In C++20, one may implement a contains function with ranges::find(haystack, needle) != ranges::end(haystack) or contains_subrange with (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) |	(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)

[edit] Example

#include #include #include   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, 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{3, 4})); #endif }

[edit] See also