std::ranges::contains, std::ranges::contains_subrange
来自cppreference.com
| 在标头 <algorithm> 定义
|
||
| 调用签名 |
||
| (1) | ||
| (C++23 起) (C++26 前) |
||
| |
(C++26 起) | |
| (2) | ||
| (C++23 起) (C++26 前) |
||
| |
(C++26 起) | |
| (3) | (C++23 起) | |
| |
(4) | (C++23 起) |
1,2) 检查给定范围是否包含值
value。1) 源范围是
[first, last)。2) 源范围是
[ranges::begin(r), ranges::end(r))。3,4) 检查第二个给定范围是否为第一个给定范围的子范围。
3) 第一个源范围是
[first1, last1)，第二个源范围是 [first2, last2)。4) 第一个源范围是
[ranges::begin(r1), ranges::end(r1))，第二个源范围是 [ranges::begin(r2), ranges::end(r2))。此页面上描述的函数式实体是算法函数对象（非正式地称为 niebloid），即：
参数
| first, last | - | 要检验的元素范围的迭代器-哨位对 |
| r | - | 要检验的元素的范围 |
| value | - | 和元素进行比较的值 |
| pred | - | 适用于投影元素的谓词 |
| proj | - | 应用到元素的投影 |
返回值
1)
ranges::find(std::move(first), last, value, proj) != last2)
ranges::find(std::move(ranges::begin(r)), ranges::end(r), value, proj) != ranges::end(r)3)
first2 == last2 || !ranges::search(first1, last1, first2, last2, pred, proj1, proj2).empty()4)
ranges::begin(r2) == ranges::end(r2) ||!ranges::search(ranges::begin(r1), ranges::end(r1),ranges::begin(r2), ranges::end(r2), pred, proj1, proj2).empty()
复杂度
1) 最多比较
ranges::distance(first, last) 次。2) 最多比较
ranges::distance(r) 次。3) 最多比较
ranges::distance(first1, last1) * ranges::distance(first2, last2) 次。4) 最多比较
ranges::distance(r1) * ranges::distance(r2) 次。注解
在 C++20 中，我们必须通过 ranges::find(r, value) != ranges::end(r) 来确定单个值是否在范围内，并通过 !std::ranges::search(haystack, needle).empty() 来检查范围是否包含感兴趣的子范围。这样做虽然准确，但并不一定方便，也很难表达意图（尤其是在后一种情况下）。如果用 std::ranges::contains(r, value) 可以解决这两个问题。
ranges::contains_subrange 和 ranges::search 类似，但和 std::search 不同，不提供对 搜索器（例如 Boyer-Moore）的支持。
| 功能特性测试宏 | 值 | 标准 | 功能特性 |
|---|---|---|---|
__cpp_lib_ranges_contains |
202207L |
(C++23) | ranges::contains 和 ranges::contains_subrange
|
__cpp_lib_algorithm_default_value_type |
202403L |
(C++26) | 算法中的列表初始化 (1,2) |
可能的实现
| 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{};
|
示例
运行此代码
#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
}
参阅
(C++20)(C++20)(C++20) |
查找首个满足特定条件的元素 (算法函数对象) |
(C++20) |
搜索元素范围的首次出现 (算法函数对象) |
(C++20) |
判断元素是否在偏序范围中 (算法函数对象) |
(C++20) |
当一个序列是另一个的子序列时返回 true (算法函数对象) |
(C++20)(C++20)(C++20) |
检查谓词是否对范围中所有、任一或无元素为 true (算法函数对象) |
