Namespaces
Variants

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

From cppreference.net
C++
Experimental
Ranges
Algorithms library
Non-modifying sequence operations
Modifying sequence operations
Partitioning operations
Sorting operations
Binary search operations
Set operations (on sorted ranges)
Heap operations
Minimum/maximum operations
Permutations
Definido en el encabezado <experimental/ranges/algorithm>
template < InputIterator I, Sentinel < I > S, class T, class Proj = ranges:: identity >

requires IndirectRelation < ranges:: equal_to <> , projected < I, Proj > , const T * >

ranges :: difference_type_t < I > count ( I first, S last, const T & value, Proj proj = Proj { } ) ;
(1) (ranges TS)
template < InputRange R, class T, class Proj = ranges:: identity >

requires IndirectRelation < ranges:: equal_to <> ,
projected < ranges:: iterator_t < R > , Proj > , const T * >
ranges :: difference_type_t < ranges:: iterator_t < R >>

count ( R && r, const T & value, Proj proj = Proj { } ) ;
(2) (ranges TS)
template < InputIterator I, Sentinel < I > S, class Proj = ranges:: identity ,

IndirectUnaryPredicate < projected < I, Proj >> Pred >

ranges :: difference_type_t < I > count_if ( I first, S last, Pred pred, Proj proj = Proj { } ) ;
(3) (ranges TS)
template < InputRange R, class Proj = ranges:: identity ,

IndirectUnaryPredicate < projected < ranges:: iterator_t < R > , Proj >> Pred >
ranges :: difference_type_t < ranges:: iterator_t < R >>

count_if ( R && r, Pred pred, Proj proj = Proj { } ) ;
(4) (ranges TS)

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

1) Cuenta los elementos cuyos valores proyectados son iguales a value (es decir, ranges:: invoke ( proj, * i ) == value ).
3) Cuenta los elementos cuyos valores proyectados satisfacen el predicado pred (es decir, ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ! = false ).
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 .

No obstante las declaraciones representadas anteriormente, el número real y el orden de los parámetros de plantilla para las declaraciones de algoritmos no está especificado. Por lo tanto, si se utilizan argumentos de plantilla explícitos al invocar un algoritmo, el programa probablemente no sea portable.

Contenidos

Parámetros

first, last - el rango de elementos a examinar
r - el rango de 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 / aplicaciones del predicado, y el mismo número de aplicaciones de la proyección.

Notas

Para el número de elementos en el rango [ first , last ) sin criterios adicionales, consulte ranges::distance .

Implementación posible

Primera versión 
template<InputIterator I, Sentinel<I> S, class T, class Proj = ranges::identity>
    requires IndirectRelation<ranges::equal_to<>, projected<I, Proj>, const T*>
ranges::difference_type_t<I> count(I first, S last, const T& value, Proj proj = Proj{})
{
    ranges::difference_type_t<I> ret = 0;
    for (; first != last; ++first)
        if (ranges::invoke(proj, *first) == value)
            ++ret;
    return ret;
}
Segunda versión 
template<InputIterator I, Sentinel<I> S, class Proj = ranges::identity,
         IndirectUnaryPredicate<projected<I, Proj>> Pred>
ranges::difference_type_t<I> count_if(I first, S last, Pred pred, Proj proj = Proj{})
{
    ranges::difference_type_t<I> ret = 0;
    for (; first != last; ++first)
        if (ranges::invoke(pred, ranges::invoke(proj, *i)))
            ++ret;
    return ret;
}

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Véase también

devuelve el número de elementos que cumplen criterios específicos
(plantilla de función)
devuelve la distancia entre un iterador y un centinela, o entre el inicio y el final de un rango
(plantilla de función)