std::unordered_set::swap(3)

okay so bestie, welcome to std::unordered_set::swap(3) from the C++ Standard Libary — manual name folded in right here so we don’t copy that header line, periodt. This is the page for swapping two unordered_sets’ whole contents, and it’s giving container-level main character energy. 💅✨

💖 NAME 💖

std::unordered_set::swap — literally std::unordered_set::swap. That’s the name, bestie. No surprises, just vibes. 🎀

🌸 Synopsis 🌸

Two synopsis eras, no cap:

void swap( unordered_set& other );                            (since C++11)
                                                                        (until C++17)
void swap( unordered_set& other ) noexcept(/* see below */);  (since C++17)

What it does: exchanges the contents of the container with those of other. It does not invoke any move, copy, or swap operations on individual elements. Like, it’s not touching the elements one by one; the containers are just swapping their whole setup. 🙈

Iterator/reference tea: all iterators and references remain valid. The end() iterator is invalidated. So your iterators keep pointing at the same elements after the swap — but end() said bye. 😭

Hash and KeyEqual tea: the Hash and KeyEqual objects must be Swappable, and they are exchanged using unqualified calls to non-member swap. That’s the exact wording, bestie.

Allocator tea (since C++11): if std::allocator_traits<allocator_type>::propagate_on_container_swap::value is true, then the allocators are exchanged using an unqualified call to non-member swap. Otherwise, they are not swapped — and if get_allocator() != other.get_allocator(), the behavior is undefined.

⚠️ That undefined behavior is not a vibe. Do not collect $200. Do not pass go. 💀

💖 Parameters 💖

• other — container to exchange the contents with

🫶 Return value 🫶

(none) — no return value, we love a clean exit. ✨

😭 Exceptions 😭

• Until C++17: any exception thrown by the swap of the Hash or KeyEqual objects. That’s it.
• Since C++17, the noexcept specification is literally:

noexcept(std::allocator_traits<Allocator>::is_always_equal::value

&& std::is_nothrow_swappable<Hash>::value

&& std::is_nothrow_swappable<key_equal>::value)

🔥 Complexity 🔥

Constant. Yes bestie, constant time — iconic behavior. 👑

🎀 Example 🎀

Here’s the code, with the // Run this code marker and everything:

// Run this code

#include <iostream>
#include <unordered_set>

template<class Os, class Co> Os& operator<<(Os& os, const Co& co)
{
    os << '{';
    for (auto const& i : co)
        os << ' ' << i;
    return os << " } ";
}

int main()
{
    std::unordered_set<int> a1{3, 1, 3, 2}, a2{5, 4, 5};

    auto it1 = std::next(a1.begin());
    auto it2 = std::next(a2.begin());

    const int& ref1 = *(a1.begin());
    const int& ref2 = *(a2.begin());

    std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' '
              << ref2 << '\n';
    a1.swap(a2);
    std::cout << a1 << a2 << *it1 << ' ' << *it2 << ' ' << ref1 << ' '
              << ref2 << '\n';

    // Note that every iterator referring to an element in one container before the swap
    // refers to the same element in the other container after the swap. Same is true
    // for references.
}

🌈 Possible output: 🌈

{ 2 1 3 } { 4 5 } 1 5 2 4
{ 4 5 } { 2 1 3 } 1 5 2 4

👑 See also 👑

• std::swap(std::unordered_set) — specializes the std::swap algorithm (C++11) (function template)

💀 Category: 💀

• conditionally noexcept

---

and that’s the cute sign-off: source/version is http://cppreference.com, date 2024.06.10, page std::unordered_set::swap(3). mwah 💋🫶