Namespaces
Variants

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

    From es.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.

    Contenido

    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 satisfacen criterios específicos
    (plantilla de función & objeto función de algoritmo)
    (C++20)(C++20)
    		devuelve la distancia entre un iterador y un centinela, o entre el inicio y el final de un rango
    (plantilla de función)