Namespaces
Variants

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

    From fr.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
    **Note:** Le contenu HTML fourni ne contient aucun texte traduisible en dehors des balises HTML et du code C++. Tous les éléments sont soit des balises HTML, des attributs, ou du code C++ qui ne doit pas être traduit selon les instructions.
    Défini dans l'en-tête <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)

    Retourne le nombre d'éléments dans la plage [ first , last ) satisfaisant des critères spécifiques.

    1) Compte les éléments dont les valeurs projetées sont égales à value (c'est-à-dire, ranges:: invoke ( proj, * i ) == value ).
    3) Compte les éléments dont les valeurs projetées satisfont le prédicat pred (c'est-à-dire, ranges:: invoke ( pred, ranges:: invoke ( proj, * i ) ) ! = false ).
    2,4) Identique à (1,3) , mais utilise r comme plage source, comme si on utilisait ranges:: begin ( r ) comme first et ranges:: end ( r ) comme last .

    Nonobstant les déclarations dépeintes ci-dessus, le nombre réel et l'ordre des paramètres de template pour les déclarations d'algorithmes ne sont pas spécifiés. Ainsi, si des arguments de template explicites sont utilisés lors de l'appel d'un algorithme, le programme est probablement non portable.

    Contenu

    Paramètres

    first, last - la plage d'éléments à examiner
    r - la plage d'éléments à examiner
    value - la valeur à rechercher
    pred - prédicat à appliquer aux éléments projetés
    proj - projection à appliquer aux éléments

    Valeur de retour

    Nombre d'éléments satisfaisant la condition.

    Complexité

    Exactement last - first comparaisons / applications du prédicat, et le même nombre d'applications de la projection.

    Notes

    Pour le nombre d'éléments dans l'intervalle [ first , last ) sans critères supplémentaires, voir ranges::distance .

    Implémentation possible

    Première version 
    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;
}
    Deuxième version 
    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;
}

    Exemple

    Cette section est incomplète
    Raison : aucun exemple

    Voir aussi

    		 retourne le nombre d'éléments satisfaisant des critères spécifiques
    (modèle de fonction & objet fonction d'algorithme)
    (C++20)(C++20)
    		retourne la distance entre un itérateur et une sentinelle, ou entre le début et la fin d'une plage
    (modèle de fonction)