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

From cppreference.net

Défini dans l'en-tête `<algorithm>`
Signature d'appel
	(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 = { } ) ;			(depuis C++20) (jusqu'à 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 = { } ) ;			(depuis 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 = { } ) ;				(depuis C++20) (jusqu'à 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 = { } ) ;				(depuis 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)	(depuis 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)	(depuis C++20)

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

1) Compte les éléments qui sont égaux à value .

3) Compte les éléments pour lesquels le prédicat p retourne true .

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 .

Les entités de type fonction décrites sur cette page sont des objets fonction d'algorithme (informellement appelés niebloids ), c'est-à-dire :

Les listes d'arguments de modèle explicites ne peuvent pas être spécifiées lors de l'appel de l'une d'entre elles.
Aucune d'entre elles n'est visible pour la recherche dépendante des arguments .
Lorsque l'une d'entre elles est trouvée par la recherche non qualifiée normale comme nom à gauche de l'opérateur d'appel de fonction, la recherche dépendante des arguments est inhibée.

Table des matières

Paramètres

first, last	-	la paire itérateur-sentinelle définissant l'intervalle des éléments à examiner
r	-	l'intervalle des é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 et projection.

Notes

Pour le nombre d'éléments dans la plage sans critères supplémentaires, voir std::ranges::distance .

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	Initialisation par liste pour les algorithmes ( 1,2 )

Implémentation possible

**Note:** Le code C++ n'a pas été traduit conformément aux instructions, car il contient des termes spécifiques au C++ et se trouve dans des balises `

`. Seul le texte environnant aurait été traduit s'il y en avait eu.

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;

Exemple

Exécuter ce code

#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;
    // déterminer combien d'entiers dans un std::vector correspondent à une valeur cible
    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 << "nombre : " << target1 << " compte : " << num_items1 << '\n';
    std::cout << "nombre : " << target2 << " compte : " << num_items2 << '\n';
    // utiliser une expression lambda pour compter les éléments divisibles par 3
    int num_items3 = ranges::count_if(v.begin(), v.end(), [](int i){ return i % 3 == 0; });
    std::cout << "nombre divisible par trois : " << num_items3 << '\n';
    // utiliser une expression lambda pour compter les éléments divisibles par 11
    int num_items11 = ranges::count_if(v, [](int i){ return i % 11 == 0; });
    std::cout << "nombre divisible par onze : " << 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);
}

Sortie :

nombre : 3 compte : 2
nombre : 5 compte : 0
nombre divisible par trois : 3
nombre divisible par onze : 0

Voir aussi

ranges::distance (C++20)	retourne la distance entre un itérateur et un sentinelle, ou entre le début et la fin d'une plage (objet fonction algorithme)
views::counted (C++20)	crée une sous-plage à partir d'un itérateur et d'un compteur (objet point de personnalisation)
ranges::filter_view views::filter (C++20)	une `view` qui consiste en les éléments d'une `range` qui satisfont un prédicat (modèle de classe) (objet adaptateur de plage)
count count_if	retourne le nombre d'éléments satisfaisant des critères spécifiques (modèle de fonction)

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