Namespaces
Variants

std::set<Key,Compare,Allocator>:: count

From cppreference.net

C++
Containers library
std::set
Member functions
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20)
Deduction guides (C++17)
size_type count ( const Key & key ) const ;
(1) (constexpr seit C++26)
template < class K >
size_type count ( const K & x ) const ;
(2) (seit C++14)
(constexpr seit C++26)

Gibt die Anzahl der Elemente zurück, deren Schlüssel zum angegebenen Argument äquivalent vergleicht.

1) Gibt die Anzahl der Elemente mit dem Schlüssel key zurück. Dies ist entweder 1 oder ​ 0 ​ , da Schlüssel immer eindeutig sind.
2) Gibt die Anzahl der Elemente zurück, deren Schlüssel äquivalent zu x verglichen wird.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn Compare transparent ist. Sie ermöglicht den Aufruf dieser Funktion ohne Konstruktion einer Instanz von Key .

Inhaltsverzeichnis

Parameter

key - Schlüsselwert der zu zählenden Elemente
x - Alternativer Wert zum Vergleich mit den Schlüsseln

Rückgabewert

Anzahl der Elemente mit Schlüssel, der äquivalent zu key oder x vergleicht.

Komplexität

Logarithmisch in der Größe des Containers plus linear in der Anzahl der gefundenen Elemente.

Hinweise

Feature-Test Makro Wert Std Funktion
__cpp_lib_generic_associative_lookup 201304L (C++14) Heterogener Vergleichslookup in assoziativen Containern ; Überladung (2)

Beispiel

Diesen Code ausführen 
#include <functional>
#include <iostream>
#include <set>
struct S
{
    int x;
    S(int i) : x{i} { std::cout << "S{" << i << "} "; }
    bool operator<(const R& s) const { return x < s.x; }
};
struct R
{
    int x;
    R(int i) : x{i} { std::cout << "R{" << i << "} "; }
    bool operator<(const R& r) const { return x < r.x; }
};
bool operator<(const R& r, int i) { return r.x < i; }
bool operator<(int i, const R& r) { return i < r.x; }
int main()
{
    std::set<int> t{3, 1, 4, 1, 5};
    std::cout << t.count(1) << ", " << t.count(2) << ".\n";
    std::set<S> s{3, 1, 4, 1, 5};
    std::cout << ": " << s.count(1) << ", " << s.count(2) << ".\n";
        // Es wurden zwei temporäre Objekte S{1} und S{2} erstellt.
        // Vergleichsfunktionsobjekt ist standardmäßig std::less<S>,
        // welches nicht transparent ist (keinen "is_transparent" Typ besitzt).
    std::set<R, std::less<>> r{3, 1, 4, 1, 5};
    std::cout << ": " << r.count(1) << ", " << r.count(2) << ".\n";
        // C++14 heterogener Lookup; temporäre Objekte wurden nicht erstellt.
        // Komparator std::less<void> besitzt vordefinierten "is_transparent".
}

Ausgabe: 

1, 0.
S{3} S{1} S{4} S{1} S{5} : S{1} 1, S{2} 0.
R{3} R{1} R{4} R{1} R{5} : 1, 0.

Siehe auch

findet Element mit spezifischem Schlüssel
(öffentliche Elementfunktion)
gibt Bereich der Elemente zurück, die einem spezifischen Schlüssel entsprechen
(öffentliche Elementfunktion)