std::count, std::count_if - cppreference.com

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody>

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

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++.

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;
}

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

#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);
}

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