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

From cppreference.net

Definiert in Header `<algorithm>`
Aufrufsignatur
	(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 = { } ) ;			(seit C++20) (bis 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 = { } ) ;			(seit 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 = { } ) ;				(seit C++20) (bis 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 = { } ) ;				(seit 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)	(seit 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)	(seit C++20)

Gibt die Anzahl der Elemente im Bereich [ first , last ) zurück, die bestimmte Kriterien erfüllen.

1) Zählt die Elemente, die gleich value sind.

3) Zählt Elemente, für die das Prädikat p true zurückgibt.

2,4) Gleich wie (1,3) , verwendet jedoch r als Quellbereich, als ob ranges:: begin ( r ) als first und ranges:: end ( r ) als last verwendet würde.

Die auf dieser Seite beschriebenen funktionsähnlichen Entitäten sind Algorithm Function Objects (informell bekannt als Niebloids ), das heißt:

Explizite Template-Argumentlisten können beim Aufruf keiner von ihnen angegeben werden.
Keiner von ihnen ist sichtbar für argument-dependent lookup .
Wenn einer von ihnen durch normal unqualified lookup als Name links vom Funktionsaufruf-Operator gefunden wird, wird argument-dependent lookup unterdrückt.

Inhaltsverzeichnis

Parameter

first, last	-	das Iterator-Sentinel-Paar, das den Bereich der zu untersuchenden Elemente definiert
r	-	der Bereich der zu untersuchenden Elemente
value	-	der zu suchende Wert
pred	-	Prädikat, das auf die projizierten Elemente angewendet wird
proj	-	Projektion, die auf die Elemente angewendet wird

Rückgabewert

Anzahl der Elemente, die die Bedingung erfüllen.

Komplexität

Genau last - first Vergleiche und Projektion.

Hinweise

Für die Anzahl der Elemente im Bereich ohne zusätzliche Kriterien, siehe std::ranges::distance .

Feature-Test Makro	Wert	Std	Funktion
`__cpp_lib_algorithm_default_value_type`	`202403`	(C++26)	Listeninitialisierung für Algorithmen ( 1,2 )

Mögliche Implementierung

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;

Beispiel

Diesen Code ausführen

#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;
    // bestimme, wie viele Ganzzahlen in einem std::vector einem Zielwert entsprechen
    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 << "number: " << target1 << " count: " << num_items1 << '\n';
    std::cout << "number: " << target2 << " count: " << num_items2 << '\n';
    // verwende einen Lambda-Ausdruck, um durch 3 teilbare Elemente zu zählen
    int num_items3 = ranges::count_if(v.begin(), v.end(), [](int i){ return i % 3 == 0; });
    std::cout << "number divisible by three: " << num_items3 << '\n';
    // verwende einen Lambda-Ausdruck, um durch 11 teilbare Elemente zu zählen
    int num_items11 = ranges::count_if(v, [](int i){ return i % 11 == 0; });
    std::cout << "number divisible by eleven: " << 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);
}

Ausgabe:

number: 3 count: 2
number: 5 count: 0
number divisible by three: 3
number divisible by eleven: 0

Siehe auch

ranges::distance (C++20)	gibt den Abstand zwischen einem Iterator und einem Sentinel oder zwischen Anfang und Ende eines Bereichs zurück (Algorithmus-Funktionsobjekt)
views::counted (C++20)	erstellt einen Subbereich aus einem Iterator und einer Anzahl (Anpassungspunktobjekt)
ranges::filter_view views::filter (C++20)	eine `view` , die aus den Elementen eines `range` besteht, die ein Prädikat erfüllen (Klassentemplate) (Bereichsadapterobjekt)
count count_if	gibt die Anzahl der Elemente zurück, die bestimmte Kriterien erfüllen (Funktionstemplate)

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