std::deque::swap(3)

💖 NAME 💖

std::deque::swap — and yep, the NAME line literally says std::deque::swap again, because that’s the vibe 💅. This page is from the C++ Standard Libary manual, bestie (that’s the manual name, keep it cute). ✨

---

🦋 Synopsis 🦋

okay so the signatures are giving two eras, and both matter:

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

This exchanges the contents of the container with those of other. It does not invoke any move, copy, or swap operations on individual elements. No cap. 🫶

All iterators and references remain valid. The end() iterator is invalidated — that one gets kicked out of the group chat 😭.

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. 💀

---

🌸 Parameters 🌸

• other — container to exchange the contents with.

---

🎀 Return value 🎀

(none) — nothing returned, just vibes. 💖

---

🧚 Exceptions 🧚

• Until C++17: (none).
• Since C++17: the noexcept specification is noexcept(std::allocator_traits<Allocator>::is_always_equal::value). ✨

---

🔥 Complexity 🔥

Constant. That’s it. Constant, slay. 👑

---

🍓 Example 🍓

The page literally says // Run this code, so here’s the sample exactly, bestie:

        #include <iostream>
        #include <deque>

        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::deque<int> a1{1, 2, 3}, a2{4, 5};

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

            int& ref1 = a1.front();
            int& ref2 = a2.front();

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

            // Note that after swap the iterators and references stay
       associated with their
            // original elements, e.g. it1 that pointed to an element in 'a1'
       with value 2
            // still points to the same element, though this element was moved
       into 'a2'.
        }

🍓 Output: 🍓

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

---

👀 See also 👀

• std::swap(std::deque) specializes the std::swap algorithm — (function template).

---

🏷️ Category: 🏷️

• conditionally noexcept — yes, that’s the category, periodt. 💅

---

Signed, sealed, and delivered from the source at http://cppreference.com, dated 2024.06.10, and filed under std::deque::swap(3). mwah 💋✨