std::ranges::contains, std::ranges::contains_subrange

在标头 `<algorithm>` 定义

调用签名
template< std::input_iterator I, std::sentinel_for<I> S, class T, class Proj = std::identity > 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 = {} );	(1)	(C++23 起)
template< ranges::input_range R, class T, class Proj = std::identity > requires std::indirect_binary_predicate<ranges::equal_to, std::projected<ranges::iterator_t<R>, Proj>, const T*> constexpr bool contains( R&& r, const T& value, Proj proj = {} );	(2)	(C++23 起)
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)	(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)	(C++23 起)

1) 基于搜索的算法，通过迭代器-哨兵对检查给定范围是否包含一个值。

2) 与 (1) 相同，但使用 r 作为源范围，就像使用 ranges::begin(r) 作为 first 和 ranges::end(r) 作为 last 一样。

3) 基于搜索的算法，通过迭代器-哨兵对检查给定范围是否包含一个值。

4) 与 (3) 相同，但使用 r1 作为第一个源范围，使用 r2 作为第二个源范围，就像使用 ranges::begin(r1) 作为 first1，ranges::end(r1) 作为 last1，ranges::begin(r2) 作为 first2，ranges::end(r2) 作为 last2。

此页面上描述的仿函数实体是 niebloid，即：

调用它们中的任何一个时不能显式指定模板实参。
它们都不对实参依赖查找可见。
在通过函数调用运算符左侧的名字进行无限定查找，找到它们之一时，禁止实参依赖查找。

实际上，它们能以函数对象，或者某些特殊编译器扩展实现。

参数

first, last	-	要检查的元素的范围
r	-	要检查的元素的范围
value	-	和元素进行比较的值
pred	-	适用于投影元素的谓词
proj	-	应用到元素的投影

返回值

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

3,4) ：first2 == last2 || !ranges::search(first1, last1, first2, last2, pred, proj1, proj2).empty()

复杂度

谓词和投影最多应用 last - first 次。

注解

在 C++20 之前，我们必须编写 std::ranges::find(r, value) != std::ranges::end(r) 来确定单个值是否在范围内。而要检查范围是否包含感兴趣的子范围，我们使用 not std::ranges::search(haystack, needle).empty()} 。这样做虽然准确，但并不一定方便，也很难表达意图（尤其是在后一种情况下）。如果用 std::ranges::contains(r, value) 可以解决这两个问题。

ranges::contains_subrange 和 ranges::search 类似，但和 std::search 不同，不提供对搜索器 (Searcher) （例如 Boyer-Moore）的支持。

功能特性测试宏	值	标准	备注
`__cpp_lib_ranges_contains`	202207L	(C++23)	`std::ranges::contains` 和 `ranges::contains_subrange`

可能的实现

contains

struct __contains_fn
{
    template<std::input_iterator I, std::sentinel_for<I> S,
             class T, class Proj = std::identity>
    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 T, class Proj = std::identity>
    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 (*this)(ranges::begin(r), ranges::end(r), std::move(value), proj);
    }
};
 
inline constexpr __contains_fn contains {};

contains_subrange

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 (*this)(ranges::begin(r1), ranges::end(r1),
                       ranges::begin(r2), ranges::end(r2), std::move(pred),
                       std::move(proj1), std::move(proj2));
    }
};
 
inline constexpr __contains_subrange_fn contains_subrange {};

示例

运行此代码

#include <algorithm>
#include <array>
 
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};
    auto increment = [](int x) { return ++x; };
    auto decrement = [](int x) { return --x; };
 
    static_assert(
        std::ranges::contains(haystack, 4) &&
       !std::ranges::contains(haystack, 6) &&
        std::ranges::contains_subrange(haystack, needle) &&
       !std::ranges::contains_subrange(haystack, bodkin) &&
        std::ranges::contains(haystack, 6, increment) &&
       !std::ranges::contains(haystack, 1, increment) &&
        std::ranges::contains_subrange(haystack, bodkin, {}, increment) &&
       !std::ranges::contains_subrange(haystack, bodkin, {}, decrement) &&
        std::ranges::contains_subrange(haystack, bodkin, {}, {}, decrement)
    );
}

参阅

ranges::findranges::find_ifranges::find_if_not (C++20)(C++20)(C++20)	查找满足特定条件的的第一个元素 (niebloid)
ranges::search (C++20)	搜索一个元素范围 (niebloid)
ranges::binary_search (C++20)	确定元素是否存在于某范围中 (niebloid)
ranges::includes (C++20)	若一个序列是另一个的子列则返回 `true` (niebloid)
ranges::all_ofranges::any_ofranges::none_of (C++20)(C++20)(C++20)	检查谓词是否对范围中所有、任一或无元素为 true (niebloid)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

std::ranges::contains, std::ranges::contains_subrange

参数

返回值

复杂度

注解

可能的实现

示例

参阅

导航