std::ranges::count, std::ranges::count_if
来自cppreference.com
| 在标头 <algorithm> 定义
|
||
| 调用签名 |
||
| (1) | (C++20 起) (C++26 前) |
|
| (C++26 起) | ||
| (2) | (C++20 起) (C++26 前) |
|
| (C++26 起) | ||
| (3) | (C++20 起) | |
| |
(4) | (C++20 起) |
| |
(5) | (C++26 起) |
| |
(6) | (C++26 起) |
| |
(7) | (C++26 起) |
| |
(8) | (C++26 起) |
/*execution-policy*/ 的定义见此页；/*sized-random-access-range*/ 的定义见此页。
返回源范围中满足特定判别标准的（以 proj 投影后的）元素个数。
1,2) 计数等于
value 的元素（使用 operator==）。1) 源范围是
[first, last)。2) 源范围是
r。3,4) 计数谓词
pred 对其返回 true 的元素。3) 源范围是
[first, last)。4) 源范围是
r。5-8) 同 (1-4)，但按照
policy 执行。此页面上描述的函数式实体是算法函数对象（非正式地称为 niebloid），即：
参数
| first, last | - | 表示源范围的迭代器-哨位对 |
| r | - | 源范围 |
| value | - | 要搜索的值 |
| pred | - | 会应用到（投影后的）元素的谓词 |
| proj | - | 会应用到元素的投影 |
| policy | - | 所用的执行策略 |
返回值
源范围中满足以下条件的迭代器 iter 的个数：
1,2,5,6)
std::invoke(proj, *iter) == value 是 true。3,4,7,8)
bool(std::invoke(pred, std::invoke(proj, *iter))) 是 true。复杂度
给定 N 为 ranges::distance(first, last) 或 ranges::distance(r)：
1,2) 应用 N 次
operator== 与 value 进行比较。3,4) 应用 N 次
pred。5,6) 应用 𝓞(N) 次
operator== 与 value 进行比较。7,8) 应用 𝓞(N) 次
pred。异常
5-8) 在执行过程中：
- 如果并行化所需的临时内存资源不可用，那么就会抛出 std::bad_alloc。
- 如果在通过算法实参访问对象时抛出了未捕获的异常，那么行为由执行策略决定（标准策略会调用 std::terminate）。
注解
对于在没有指定任何额外判别标准时的某个范围中的元素数，见 ranges::distance。
| 功能特性测试宏 | 值 | 标准 | 功能特性 |
|---|---|---|---|
__cpp_lib_algorithm_default_value_type |
202403 |
(C++26) | 算法中的列表初始化 (1,2) |
可能的实现
| count |
|---|
struct count_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 std::iter_difference_t<I>
operator()(I first, S last, const T& value, Proj proj = {}) const
{
std::iter_difference_t<I> counter = 0;
for (; first != last; ++first)
if (std::invoke(proj, *first) == value)
++counter;
return counter;
}
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 ranges::range_difference_t<R>
operator()(R&& r, const T& value, Proj proj = {}) const
{
return (*this)(ranges::begin(r), ranges::end(r), value, std::ref(proj));
}
template<ranges::forward_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 ranges::range_difference_t<R>
operator()(R&& r, const T& value, Proj proj = {}) const
{
return (*this)(ranges::begin(r),
ranges::next(ranges::begin(r), ranges::end(r)),
value, std::ref(proj));
}
};
inline constexpr count_fn count;
|
| count_if |
struct count_if_fn
{
template<std::input_iterator I, std::sentinel_for<I> S,
class Proj = std::identity,
std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
constexpr std::iter_difference_t<I>
operator()(I first, S last, Pred pred, Proj proj = {}) const
{
std::iter_difference_t<I> counter = 0;
for (; first != last; ++first)
if (std::invoke(pred, std::invoke(proj, *first)))
++counter;
return counter;
}
template<ranges::input_range R, class Proj = std::identity,
std::indirect_unary_predicate
<std::projected<ranges::iterator_t<R>, Proj>> Pred>
constexpr ranges::range_difference_t<R>
operator()(R&& r, Pred pred, Proj proj = {}) const
{
return (*this)(ranges::begin(r), ranges::end(r),
std::ref(pred), std::ref(proj));
}
template<ranges::forward_range R, class Proj = std::identity,
std::indirect_unary_predicate
<std::projected<ranges::iterator_t<R>, Proj>> Pred>
constexpr ranges::range_difference_t<R>
operator()(R&& r, Pred pred, Proj proj = {}) const
{
return (*this)(ranges::begin(r),
ranges::next(ranges::begin(r), ranges::end(r)),
std::ref(pred), std::ref(proj));
}
};
inline constexpr count_if_fn count_if;
|
示例
Run this code
#include <algorithm>
#include <cassert>
#include <complex>
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v{1, 2, 3, 4, 4, 3, 7, 8, 9, 10};
namespace ranges = std::ranges;
// 确定 std::vector 中有多少整数匹配目标值。
int target1 = 3;
int target2 = 5;
int num_items1 = ranges::count(v.begin(), v.end(), target1);
int num_items2 = ranges::count(v, target2);
std::cout << "数字：" << target1 << " 计数：" << num_items1 << '\n';
std::cout << "数字：" << target2 << " 计数：" << num_items2 << '\n';
// 用 lambda 表达式计数被 3 整除的元素。
int num_items3 = ranges::count_if(v.begin(), v.end(), [](int i){ return i % 3 == 0; });
std::cout << "可以被 3 整除的数字：" << num_items3 << '\n';
// 用 lambda 表达式计数被 11 整除的元素。
int num_items11 = ranges::count_if(v, [](int i){ return i % 11 == 0; });
std::cout << "可以被 11 整除的数字：" << num_items11 << '\n';
std::vector<std::complex<double>> nums{{4, 2}, {1, 3}, {4, 2}};
#ifdef __cpp_lib_algorithm_default_value_type
auto c = ranges::count(nums, {4, 2});
#else
auto c = ranges::count(nums, std::complex<double>{4, 2});
#endif
assert(c == 2);
}
输出：
数字：3 计数：2
数字：5 计数：0
可以被 3 整除的数字：3
可以被 11 整除的数字：0
参阅
| 返回满足特定条件的元素数目 (函数模板) | |
(C++20) |
返回迭代器与哨位间的距离，或范围起始与结尾间的距离 (算法函数对象) |
(C++20) |
从迭代器和计数创建子范围 (定制点对象) |
| 由 range 中满足某个谓词的元素构成的 view (类模板) (范围适配器对象) |