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 depuis C++26)
template < class K >
size_type count ( const K & x ) const ;
(2) (depuis C++14)
(constexpr depuis C++26)

Retourne le nombre d'éléments dont la clé est équivalente à l'argument spécifié.

1) Retourne le nombre d'éléments avec la clé key . Ceci est soit 1 soit ​ 0 ​ puisque les clés sont toujours uniques.
2) Retourne le nombre d'éléments dont la clé est équivalente à x .
Cette surcharge participe à la résolution de surcharge uniquement si Compare est transparent . Elle permet d'appeler cette fonction sans construire une instance de Key .

Table des matières

Paramètres

key - valeur clé des éléments à compter
x - valeur alternative à comparer aux clés

Valeur de retour

Nombre d'éléments dont la clé est équivalente à key ou x .

Complexité

Logarithmique par rapport à la taille du conteneur plus linéaire par rapport au nombre d'éléments trouvés.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_generic_associative_lookup 201304L (C++14) Recherche de comparaison hétérogène dans les conteneurs associatifs ; surcharge (2)

Exemple

Exécuter ce code 
#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";
        // Deux objets temporaires S{1} et S{2} ont été créés.
        // L'objet fonction de comparaison est par défaut std::less<S>,
        // qui n'est pas transparent (n'a pas de type imbriqué "is_transparent").
    std::set<R, std::less<>> r{3, 1, 4, 1, 5};
    std::cout << ": " << r.count(1) << ", " << r.count(2) << ".\n";
        // Recherche hétérogène C++14 ; aucun objet temporaire n'a été créé.
        // Le comparateur std::less<void> possède "is_transparent" prédéfini.
}

Sortie : 

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.

Voir aussi

trouve l'élément avec une clé spécifique
(fonction membre publique)
retourne la plage d'éléments correspondant à une clé spécifique
(fonction membre publique)