std::unordered_map::find(3)

💅 std::unordered_map::find(3) — C++ Standard Libary 💅

okay so bestie, welcome to the std::unordered_map::find page from the C++ Standard Libary manual. It’s giving “where is my element” energy, and the answer comes back as an iterator. No cap. 🫶

🌸 NAME 🌸

std::unordered_map::find — std::unordered_map::find

literally the same thing twice, but make it iconic. 💅

✨ Synopsis ✨

okay so here are all four overloads, and yes they are all important. Keep every const exactly where it is. 🎀

iterator find( const Key& key );             (1) (since C++11)
const_iterator find( const Key& key ) const; (2) (since C++11)
template< class K >                          (3) (since C++20)
iterator find( const K& x );
template< class K >                          (4) (since C++20)
const_iterator find( const K& x ) const;

1,2) Finds an element with key equivalent to key.

3,4) Finds an element with key that compares equivalent to the value 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.

The way overloads (3,4) only show up when those transparency conditions are valid is lowkey very specific, but highkey iconic. iykyk. 🔥

🎀 Parameters 🎀

• key — key value of the element to search for
• x — a value of any type that can be transparently compared with a key

🦋 Return value 🦋

An iterator to the requested element. If no such element is found, past-the-end (see end()) iterator is returned. So if you get end(), that’s the vibe check saying “not here, bestie.” 😭

🔥 Complexity 🔥

Constant on average, worst case linear in the size of the container.

ngl, average is giving slay, worst case is giving “why is this container so big.” 💀

📝 Notes 📝

Feature-test macro moment, because C++20 said “let there be heterogeneous lookup.” ✨

• Feature-test macro: __cpp_lib_generic_unordered_lookup
  • Value: 201811L
  • Std: (C++20)
  • Feature: Heterogeneous comparison lookup in unordered associative containers; overloads (3,4)

🍓 Example 🍓

This is the “run this code” moment. Copy it exactly, bestie — every include, every s, every sv. fr fr.

// Run this code

#include <cstddef>
#include <functional>
#include <iostream>
#include <string>
#include <string_view>
#include <unordered_map>

using namespace std::literals;

struct string_hash
{
    using hash_type = std::hash<std::string_view>;
    using is_transparent = void;

    std::size_t operator()(const char* str) const        { return hash_type{}(str); }
    std::size_t operator()(std::string_view str) const   { return hash_type{}(str); }
    std::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'}};

    if (auto search = example.find(2); 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

👑 See also 👑

• count — returns the number of elements matching specific key (public member function)
• equal_range — returns range of elements matching a specific key (public member function)

---

okay that’s the whole page, bestie. Source/version: http://cppreference.com · date: 2024.06.10 · page: std::unordered_map::find(3). Go find your element and slay. 💖✨