std::list::resize(3)

🦋 std::list::resize(3) 🦋

okay bestie, welcome to the C++ Standard Libary manual page for std::list::resize 💅 this one is short and sweet but still ate, fr fr.

---

✨ NAME ✨

std::list::resize - std::list::resize

(no cap, that’s literally what the NAME section says 😭)

---

🌸 Synopsis 🌸

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

So resize resizes the container to contain count elements, and does nothing if count == size(). Iconic behavior, honestly.

If the current size is greater than count, the container is reduced to its first count elements.

If the current size is less than count:

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

---

🎀 Parameters 🎀

• count — new size of the container
• value — the value to initialize the new elements with

---

🫶 Type requirements 🫶

• T must meet the requirements of DefaultInsertable in order to use overload (1).
• T must meet the requirements of CopyInsertable in order to use overload (2).

---

💖 Return value 💖

(none) — literally nothing comes back, bestie.

---

🔥 Complexity 🔥

Linear in the difference between the current size and count.

---

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

---

🍓 Example 🍓

// Run this code

#include <list>
#include <iostream>

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

int main()
{
    std::list<int> c = {1, 2, 3};
    print("The list 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 list 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

---

🧚 Defect reports 🧚

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

• DR LWG 132 — Applied to: C++98. Behavior as published: random-access iterators were used to determine the erase range. Correct behavior: use bidirectional iterators.
• DR LWG 679 — Applied to: C++98. Behavior as published: resize() passed value by value. Correct behavior: passes by const reference.
• DR LWG 1420 — Applied to: C++98. Behavior as published: the behavior of resize(size()) was not specified. Correct behavior: specified.

---

👑 See also 👑

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

---

this cutie came from http://cppreference.com, dated 2024.06.10, and the page is std::list::resize(3) — byeee 🫶💖