std:: count, std:: count_if

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

Parameter

Rückgabewert

Die Anzahl der Iteratoren it in dem Bereich [ first , last ) die folgende Bedingung erfüllen:

Komplexität

Gegeben \(\scriptsize N\) N als std:: distance ( first, last ) :

Ausnahmen

Die Überladungen mit einem Template-Parameter namens ExecutionPolicy melden Fehler wie folgt:

• Wenn die Ausführung einer als Teil des Algorithmus aufgerufenen Funktion eine Exception wirft und ExecutionPolicy einer der Standard-Policies ist, wird std::terminate aufgerufen. Für jede andere ExecutionPolicy ist das Verhalten implementierungsdefiniert.
• Wenn der Algorithmus keinen Speicher allozieren kann, wird std::bad_alloc geworfen.

Hinweise

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

Mögliche Implementierung

Siehe auch die Implementierungen von count in libstdc++ und libc++ .

Siehe auch die Implementierungen von count_if in libstdc++ und libc++ .

template<class InputIt, class T = typename std::iterator_traits<InputIt>::value_type>
typename std::iterator_traits<InputIt>::difference_type
    count(InputIt first, InputIt last, const T& value)
{
    typename std::iterator_traits<InputIt>::difference_type ret = 0;
    for (; first != last; ++first)
        if (*first == value)
            ++ret;
    return ret;
}

template<class InputIt, class UnaryPred>
typename std::iterator_traits<InputIt>::difference_type
    count_if(InputIt first, InputIt last, UnaryPred p)
{
    typename std::iterator_traits<InputIt>::difference_type ret = 0;
    for (; first != last; ++first)
        if (p(*first))
            ++ret;
    return ret;
}

`-Tags wurde gemäß den Anweisungen nicht übersetzt, da er technischen Code enthält. Die HTML-Struktur und Attribute bleiben ebenfalls unverändert.

Beispiel

#include <algorithm>
#include <array>
#include <cassert>
#include <complex>
#include <iostream>
#include <iterator>
int main()
{
    constexpr std::array v{1, 2, 3, 4, 4, 3, 7, 8, 9, 10};
    std::cout << "v: ";
    std::copy(v.cbegin(), v.cend(), std::ostream_iterator<int>(std::cout, " "));
    std::cout << '\n';
    // Bestimme, wie viele Ganzzahlen einem Zielwert entsprechen.
    for (const int target : {3, 4, 5})
    {
        const int num_items = std::count(v.cbegin(), v.cend(), target);
        std::cout << "Zahl: " << target << ", Anzahl: " << num_items << '\n';
    }
    // Verwende einen Lambda-Ausdruck, um durch 4 teilbare Elemente zu zählen.
    int count_div4 = std::count_if(v.begin(), v.end(), [](int i) { return i % 4 == 0; });
    std::cout << "durch vier teilbare Zahlen: " << count_div4 << '\n';
    // Eine vereinfachte Version von `distance` mit O(N)-Komplexität:
    auto distance = [](auto first, auto last)
    {
        return std::count_if(first, last, [](auto) { return true; });
    };
    static_assert(distance(v.begin(), v.end()) == 10);
    std::array<std::complex<double>, 3> nums{{{4, 2}, {1, 3}, {4, 2}}};
    #ifdef __cpp_lib_algorithm_default_value_type
        // T wird abgeleitet, was die Listeninitialisierung ermöglicht
        auto c = std::count(nums.cbegin(), nums.cend(), {4, 2});
    #else
        auto c = std::count(nums.cbegin(), nums.cend(), std::complex<double>{4, 2});
    #endif
    assert(c == 2);
}

v: 1 2 3 4 4 3 7 8 9 10
Zahl: 3, Anzahl: 2
Zahl: 4, Anzahl: 2
Zahl: 5, Anzahl: 0
durch vier teilbare Zahlen: 3

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Siehe auch