iterator find( const Key& key ); | (1) | |
const_iterator find( const Key& key ) const; | (2) | |
template< class K > iterator find( const K& x ); | (3) | (since C++20) |
template< class K > const_iterator find( const K& x ) const; | (4) | (since C++20) |
key
. x
. This overload participates in overload resolution only if Hash::is_transparent
and KeyEqual::is_transparent
are valid and each denotes a type. This assumes that such Hash
is callable with both K
and Key
type, and that the KeyEqual
is transparent, which, together, allows calling this function without constructing an instance of Key
.key | - | key value of the element to search for |
x | - | a value of any type that can be transparently compared with a key |
Iterator to an element with key equivalent to key
. If no such element is found, past-the-end (see end()
) iterator is returned.
Constant on average, worst case linear in the size of the container.
Feature-test macro | Comment |
---|---|
__cpp_lib_generic_unordered_lookup | for overloads (3,4) |
#include <cstddef> #include <iostream> #include <functional> #include <string> #include <string_view> #include <unordered_map> using namespace std::literals; using std::size_t; struct string_hash { using hash_type = std::hash<std::string_view>; using is_transparent = void; size_t operator()(const char* str) const { return hash_type{}(str); } size_t operator()(std::string_view str) const { return hash_type{}(str); } size_t operator()(std::string const& str) const { return hash_type{}(str); } }; int main() { // simple comparison demo std::unordered_map<int,char> example = {{1,'a'},{2,'b'}}; auto search = example.find(2); if (search != example.end()) { std::cout << "Found " << search->first << " " << search->second << '\n'; } else { std::cout << "Not found\n"; } // C++20 demo: Heterogeneous lookup for unordered containers (transparent hashing) std::unordered_map<std::string, size_t, string_hash, std::equal_to<>> map{ {"one"s, 1} }; std::cout << std::boolalpha << (map.find("one") != map.end()) << '\n' << (map.find("one"s) != map.end()) << '\n' << (map.find("one"sv) != map.end()) << '\n'; }
Output:
Found 2 b true true true
(C++11) | returns the number of elements matching specific key (public member function) |
(C++11) | returns range of elements matching a specific key (public member function) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/container/unordered_map/find