Namespaces
Variants

std::multiset<Key,Compare,Allocator>:: find

From cppreference.net

C++
Containers library
std::multiset
Member functions
Non-member functions
Deduction guides (C++17)
iterator find ( const Key & key ) ;
(1) (constexpr depuis C++26)
const_iterator find ( const Key & key ) const ;
(2) (constexpr depuis C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (depuis C++14)
(constexpr depuis C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (depuis C++14)
(constexpr depuis C++26)
1,2) Trouve un élément dont la clé est équivalente à key . Si plusieurs éléments avec la clé demandée sont présents dans le conteneur, n'importe lequel d'entre eux peut être retourné.
3,4) Trouve un élément 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é de l'élément à rechercher
x - une valeur de type quelconque pouvant être comparée de manière transparente avec une clé

Valeur de retour

Un itérateur vers l'élément demandé. Si aucun élément correspondant n'est trouvé, un itérateur past-the-end (voir end() ) est retourné.

Complexité

Logarithmique par rapport à la taille du conteneur.

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 ; surcharges ( 3,4 )

Exemple

Exécuter ce code 
#include <iostream>
#include <set>
struct LightKey
{
    int x;
};
struct FatKey
{
    int x;
    int data[1000]; // un bloc lourd
};
// Comme détaillé ci-dessus, le conteneur doit utiliser std::less<> (ou un autre
// comparateur transparent) pour accéder à ces surcharges. Cela inclut les surcharges
// standard, telles que la comparaison entre std::string et std::string_view.
bool operator<(const FatKey& fk, const LightKey& lk) { return fk.x < lk.x; }
bool operator<(const LightKey& lk, const FatKey& fk) { return lk.x < fk.x; }
bool operator<(const FatKey& fk1, const FatKey& fk2) { return fk1.x < fk2.x; }
int main()
{
    // Démonstration de comparaison simple.
    std::multiset<int> example{1, 2, 3, 4};
    if (auto search = example.find(2); search != example.end())
        std::cout << "Found " << (*search) << '\n';
    else
        std::cout << "Not found\n";
    // Démonstration de comparaison transparente.
    std::multiset<FatKey, std::less<>> example2{{1, {}}, {2, {}}, {3, {}}, {4, {}}};
    LightKey lk = {2};
    if (auto search = example2.find(lk); search != example2.end())
        std::cout << "Found " << search->x << '\n';
    else
        std::cout << "Not found\n";
}

Sortie : 

Found 2
Found 2

Voir aussi

renvoie le nombre d'éléments correspondant à une clé spécifique
(fonction membre publique)
renvoie la plage d'éléments correspondant à une clé spécifique
(fonction membre publique)