std::deque::resize(3)

💜 std::deque::resize(3) 💜

okay bestie, so this is a page from the C++ Standard Library manual, and today's main character is std::deque::resize — the glow-up/down-slash for your deque ✨

---

🌸 NAME 🌸

std::deque::resize — bestie, it's literally std::deque::resize. that's the whole name. iconic of it tbh 💅

---

✨ SYNOPSIS ✨

void resize( size_type count );                          (1)
void resize( size_type count, const value_type& value ); (2)

So here's the tea: it resizes the container so it contains count elements — and if count == size() it literally does nothing. no cap, zero effort, we love a low-maintenance function 🫶

If the current size is greater than count, the container gets reduced to its first count elements (bye bestie 👋).

If the current size is less than count, then:

1. additional default-inserted elements are appended.
2. additional copies of value are appended.

---

🎀 PARAMETERS 🎀

• count — the new size of the container, i.e. how many elements we're fitting in this fit 🦋
• value — the value used to initialize the new elements with 💖

---

🧚 TYPE REQUIREMENTS 🧚

• T must meet the requirements of MoveInsertable and DefaultInsertable in order to use overload (1). them's the rules fr fr.
• T must meet the requirements of CopyInsertable in order to use overload (2).

---

⭐ RETURN VALUE ⭐

(none) — it gives you nothing back. not a crumb. but honestly? the real reward was the elements we resized along the way 😭

---

🔥 COMPLEXITY 🔥

Linear in the difference between the current size and count. so the more you resize, the more work it does — plan accordingly bestie 🌈

---

💅 NOTES 💅

If value-initialization in overload (1) is undesirable — for example, if the elements are of non-class type and zeroing out is not needed — it can be avoided by providing a custom Allocator::construct. fancy custom behavior, we stan a bespoke allocator 👑

---

🌸 EXAMPLE 🌸

// Run this code

#include <deque>
#include <iostream>

void print(auto rem, const std::deque<int>& c)
{
    for (std::cout << rem; const int el : c)
        std::cout << el << ' ';
    std::cout << '\n';
}

int main()
{
    std::deque<int> c = {1, 2, 3};
    print("The deque holds: ", c);

    c.resize(5);
    print("After resize up to 5: ", c);

    c.resize(2);
    print("After resize down to 2: ", c);

    c.resize(6, 4);
    print("After resize up to 6 (initializer = 4): ", c);
}

---

🦋 OUTPUT 🦋

The deque holds: 1 2 3
After resize up to 5: 1 2 3 0 0
After resize down to 2: 1 2
After resize up to 6 (initializer = 4): 1 2 4 4 4 4

look at those zeros showing up out of nowhere — default insertion really said "i'm the main character now" 💀✨

---

👑 DEFECT REPORTS 👑

The following behavior-changing defect reports were applied retroactively to previously published C++ standards. so like, the standard got a patch and we're all just living in the fixed timeline 🫶

• LWG 679 — applied to C++98 — behavior as published: resize() passed value by value → correct behavior: passes by const reference.
• LWG 1418 — applied to C++98 — behavior as published: the behavior of resize(size()) was not specified → correct behavior: specified.
• LWG 2033 — applied to C++11 — behavior as published: 1. elements were removed by using erase(); 2. T was not required to be MoveInsertable → correct behavior: 1. uses pop_back(); 2. required.

---

🍓 SEE ALSO 🍓

• size — returns the number of elements (public member function) 📏
• insert — inserts elements (public member function) ➕
• erase — erases elements (public member function) ➖

---

okay that's the whole page bestie, you're now officially a std::deque::resize scholar 🎓💖 this was pulled from http://cppreference.com, dated 2024.06.10 — so it's giving vintage-but-still-slaying, and it's filed under std::deque::resize(3). mwah 💋✨