std::ranges:: count, std::ranges:: count_if

From cppreference.net

Definido en el encabezado `<algorithm>`
Firma de llamada
	(1)
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 std:: iter_difference_t < I > count ( I first, S last, const T & value, Proj proj = { } ) ;			(desde C++20) (hasta C++26)
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 > count ( I first, S last, const T & value, Proj proj = { } ) ;			(desde C++26)
		(2)
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 ranges:: range_difference_t < R > count ( R && r, const T & value, Proj proj = { } ) ;				(desde C++20) (hasta C++26)
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 > count ( R && r, const T & value, Proj proj = { } ) ;				(desde C++26)
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 > count_if ( I first, S last, Pred pred, Proj proj = { } ) ;			(3)	(desde C++20)
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 > count_if ( R && r, Pred pred, Proj proj = { } ) ;			(4)	(desde C++20)

Devuelve el número de elementos en el rango [ first , last ) que satisfacen criterios específicos.

1) Cuenta los elementos que son iguales a value .

3) Cuenta elementos para los cuales el predicado p devuelve true .

2,4) Igual que (1,3) , pero utiliza r como el rango fuente, como si usara ranges:: begin ( r ) como first y ranges:: end ( r ) como last .

Las entidades similares a funciones descritas en esta página son algorithm function objects (conocidas informalmente como niebloids ), es decir:

No se pueden especificar listas de argumentos de plantilla explícitas al llamar a cualquiera de ellos.
Ninguno de ellos es visible para la búsqueda dependiente de argumento .
Cuando cualquiera de ellos es encontrado mediante la búsqueda no calificada normal como el nombre a la izquierda del operador de llamada a función, la búsqueda dependiente de argumento queda inhibida.

Contenidos

Parámetros

first, last	-	el par iterador-centinela que define el rango de elementos a examinar
r	-	el rango de los elementos a examinar
value	-	el valor a buscar
pred	-	predicado a aplicar a los elementos proyectados
proj	-	proyección a aplicar a los elementos

Valor de retorno

Número de elementos que satisfacen la condición.

Complejidad

Exactamente last - first comparaciones y proyección.

Notas

Para el número de elementos en el rango sin criterios adicionales, consulte std::ranges::distance .

Macro de prueba de características	Valor	Estándar	Característica
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	Inicialización por lista para algoritmos ( 1,2 )

Implementación posible

count (1)

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));
    }
};
inline constexpr count_fn count;

count_if (3)

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));
    }
};
inline constexpr count_if_fn count_if;

Ejemplo

Ejecutar este código

#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;
    // determinar cuántos enteros en un std::vector coinciden con un valor objetivo
    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 << "número: " << target1 << " conteo: " << num_items1 << '\n';
    std::cout << "número: " << target2 << " conteo: " << num_items2 << '\n';
    // usar una expresión lambda para contar elementos divisibles por 3
    int num_items3 = ranges::count_if(v.begin(), v.end(), [](int i){ return i % 3 == 0; });
    std::cout << "número divisible por tres: " << num_items3 << '\n';
    // usar una expresión lambda para contar elementos divisibles por 11
    int num_items11 = ranges::count_if(v, [](int i){ return i % 11 == 0; });
    std::cout << "número divisible por once: " << 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);
}

Salida:

número: 3 conteo: 2
número: 5 conteo: 0
número divisible por tres: 3
número divisible por once: 0

Véase también

ranges::distance (C++20)	devuelve la distancia entre un iterador y un centinela, o entre el inicio y el final de un rango (objeto función algoritmo)
views::counted (C++20)	crea un subrango a partir de un iterador y un contador (objeto punto de personalización)
ranges::filter_view views::filter (C++20)	una `view` que consiste en los elementos de un `range` que satisfacen un predicado (plantilla de clase) (objeto adaptador de rango)
count count_if	devuelve el número de elementos que cumplen criterios específicos (plantilla de función)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants