std::count, std::count_if
De cppreference.com
<tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
<tbody class="t-dcl-rev t-dcl-rev-num ">
</tbody><tbody>
</tbody>
| Definido en el archivo de encabezado <algorithm>
|
||
| (1) | ||
template< class InputIt, class T > typename iterator_traits<InputIt>::difference_type count( InputIt first, InputIt last, const T &value ); |
(hasta C++20) | |
template< class InputIt, class T > constexpr typename iterator_traits<InputIt>::difference_type count( InputIt first, InputIt last, const T &value ); |
(desde C++20) | |
template< class ExecutionPolicy, class ForwardIt, class T > typename iterator_traits<ForwardIt>::difference_type count( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, const T &value ); |
(2) | (desde C++17) |
| (3) | ||
template< class InputIt, class UnaryPredicate > typename iterator_traits<InputIt>::difference_type count_if( InputIt first, InputIt last, UnaryPredicate p ); |
(hasta C++20) | |
template< class InputIt, class UnaryPredicate > constexpr typename iterator_traits<InputIt>::difference_type count_if( InputIt first, InputIt last, UnaryPredicate p ); |
(desde C++20) | |
template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate > typename iterator_traits<ForwardIt>::difference_type count_if( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, UnaryPredicate p ); |
(4) | (desde C++17) |
Devuelve el número de elementos en el rango [first, last) que satisfacen el criterio especificado.
1) Cuenta los elementos que son iguales que
value.3) Cuenta los elementos para los que el predicado
p devuelve true.2,4) Igual que (1,3), pero ejecutado de acuerdo a la política
policy. Estas sobrecargas no participan en la resolución de sobrecarga a menos que std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> (hasta C++20) std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> (desde C++20) sea verdadera.Parámetros
| first, last | - | El rango de elementos a examinar. |
| value | - | El valor a buscar. |
| policy | - | La política de ejecución a usar. Véase política de ejecución para más detalles. |
| p | - | Predicado unario que devuelve true para los elementos requeridos. La expresión |
| Requisitos de tipo | ||
-InputIt debe satisfacer los requisitos de InputIterator.
| ||
-ForwardIt debe satisfacer los requisitos de ForwardIterator.
| ||
Valor de retorno
El número de elementos que satisfacen la condición.
Complejidad
Exactamente last - first comparaciones o aplicaciones del predicado.
Excepciones
Las sobrecargas con un parámetro de plantilla llamado ExecutionPolicy (política de ejecución) reportan errores tales que:
- Si la ejecución de una función invocada como parte del algoritmo lanza una excepción y la política de ejecución es una de las tres políticas estándar, se llama a std::terminate. Para cualquier otra política de ejecución, el comportamiento está definido por la implementación.
- Si el algoritmo falla al asignar memoria, se lanza std::bad_alloc.
Notas
Para el número de elementos en el rango [first, last) sin ningún criterio adicional véase std::distance.
Posible implementación
Véanse también las implementaciones de count en libstdc++ y libc++.
Véanse también las implementaciones de count_if en libstdc++ y libc++.
| Primera versión |
|---|
template<class InputIt, class T>
typename iterator_traits<InputIt>::difference_type
count(InputIt first, InputIt last, const T& value)
{
typename iterator_traits<InputIt>::difference_type ret = 0;
for (; first != last; ++first) {
if (*first == value) {
ret++;
}
}
return ret;
}
|
| Segunda versión |
template<class InputIt, class UnaryPredicate>
typename iterator_traits<InputIt>::difference_type
count_if(InputIt first, InputIt last, UnaryPredicate p)
{
typename iterator_traits<InputIt>::difference_type ret = 0;
for (; first != last; ++first) {
if (p(*first)) {
ret++;
}
}
return ret;
}
|
Ejemplo
Ejecuta este código
#include <algorithm>
#include <iostream>
#include <iterator>
#include <array>
int main()
{
constexpr std::array v = { 1, 2, 3, 4, 4, 3, 7, 8, 9, 10 };
std::cout << "v: ";
std::copy(v.cbegin(), v.cend(), std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
// determinar cuántos enteros coinciden con un valor objetivo.
for (const int objetivo: {3, 4, 5}) {
const int num_items = std::count(v.cbegin(), v.cend(), objetivo);
std::cout << "número: " << objetivo << ", cuenta: " << num_items << '\n';
}
// usar una expresión lambda para contar los elementos divisibles por 4.
int cuenta_div4 = std::count_if(v.begin(), v.end(), [](int i){return i % 4 == 0;});
std::cout << "números divisible por cuatro: " << cuenta_div4 << '\n';
// una versión simplificada de `distance` con complejidad O(N):
auto distance = [](auto first, auto last) {
return std::count_if(first, last, [](auto){return true;});
};
static_assert(distance(v.begin(), v.end()) == 10);
}
Salida:
v: 1 2 3 4 4 3 7 8 9 10
número: 3, cuenta: 2
número: 4, cuenta: 2
número: 5, cuenta: 0
números divisible por cuatro: 3
Véase también
| Devuelve la distancia entre dos iteradores. (función) | |
(C++20)(C++20) |
Devuelve el número de elementos que cumplan con un criterio específico. (niebloid) |