Namespaces
Variants

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

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)
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 .
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 Norme 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]; // a heavy blob
};
// As detailed above, the container must use std::less<> (or other transparent
// Comparator) to access these overloads. This includes standard overloads,
// such as comparison between std::string and 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()
{
    // Simple comparison demo.
    std::set<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";
    // Transparent comparison demo.
    std::set<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

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