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

Table des matières

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

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