Namespaces
Variants

std::unordered_set<Key,Hash,KeyEqual,Allocator>:: find

From cppreference.net

C++
Containers library
std::unordered_set
Member types
Member functions
Non-member functions
Deduction guides (C++17)
iterator find ( const Key & key ) ;
(1) (depuis C++11)
(constexpr depuis C++26)
const_iterator find ( const Key & key ) const ;
(2) (depuis C++11)
(constexpr depuis C++26)
template < class K >
iterator find ( const K & x ) ;
(3) (depuis C++20)
(constexpr depuis C++26)
template < class K >
const_iterator find ( const K & x ) const ;
(4) (depuis C++20)
(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 Hash et KeyEqual sont tous deux transparents . Cela suppose qu'un tel Hash peut être appelé avec les types K et Key , et que le KeyEqual est transparent, ce qui, ensemble, 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 passé-la-fin (voir end() ) est retourné.

Complexité

Constant en moyenne, pire cas linéaire dans la taille du conteneur.

Notes

Macro de test de fonctionnalité Valeur Std Fonctionnalité
__cpp_lib_generic_unordered_lookup 201811L (C++20) Recherche de comparaison hétérogène dans les conteneurs associatifs non ordonnés ; surcharges ( 3,4 )

Exemple

Exécuter ce code 
#include <cstddef>
#include <functional>
#include <iostream>
#include <source_location>
#include <string>
#include <string_view>
#include <unordered_set>
using namespace std::literals;
namespace logger { bool enabled{false}; }
inline void who(const std::source_location sloc = std::source_location::current())
{
    if (logger::enabled)
        std::cout << sloc.function_name() << '\n';
}
struct string_hash // C++20's transparent hashing
{
    using hash_type = std::hash<std::string_view>;
    using is_transparent = void;
    std::size_t operator()(const char* str) const
    {
        who();
        return hash_type{}(str);
    }
    std::size_t operator()(std::string_view str) const
    {
        who();
        return hash_type{}(str);
    }
    std::size_t operator()(const std::string& str) const
    {
        who();
        return hash_type{}(str);
    }
};
int main()
{
    std::unordered_set<int> example{1, 2, -10};
    std::cout << "Simple comparison demo:\n" << std::boolalpha;
    if (auto search = example.find(2); search != example.end())
        std::cout << "Found " << *search << '\n';
    else
        std::cout << "Not found\n";
    std::unordered_set<std::string, string_hash, std::equal_to<>> set{"one"s, "two"s};
    logger::enabled = true;
    std::cout << "Heterogeneous lookup for unordered containers (transparent hashing):\n"
              << (set.find("one")   != set.end()) << '\n'
              << (set.find("one"s)  != set.end()) << '\n'
              << (set.find("one"sv) != set.end()) << '\n';
}

Sortie possible : 

Simple comparison demo:
Found 2
Heterogeneous lookup for unordered containers (transparent hashing):
std::size_t string_hash::operator()(const char*) const
true
std::size_t string_hash::operator()(const std::string&) const
true
std::size_t string_hash::operator()(std::string_view) const
true

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)