std::basic_...c_stacktrace(3)

💅 NAME 💅

okay bestie, this is the std::basic_...c_stacktrace(3) page from the <pink>C++ Standard Libary</pink> manual (their spelling, not mine 😭), and it's all about std::basic_stacktrace::basic_stacktrace — yes, the constructor squad for std::basic_stacktrace. every overload here is (since C++23), so it's giving shiny new standard energy ✨💅

---

🌸 SYNOPSIS 🌸

here's the exact synopsis, weird wrapping and all, no cap:

          basic_stacktrace() noexcept(/* see below */);
       (1) (since C++23)
          explicit basic_stacktrace( const allocator_type& alloc ) noexcept;
       (2) (since C++23)
          basic_stacktrace( const basic_stacktrace& other );
       (3) (since C++23)
          basic_stacktrace( basic_stacktrace&& other ) noexcept;
       (4) (since C++23)
          basic_stacktrace( const basic_stacktrace& other,
       (5) (since C++23)
                            const allocator_type& alloc );
          basic_stacktrace( basic_stacktrace&& other, const allocator_type&
       (6) (since C++23)
          alloc );

so the whole vibe is: it constructs an empty basic_stacktrace, or it copies/moves from other. lowkey iconic constructor behavior 🫶

1. Overload (1) — default constructor. Constructs an empty basic_stacktrace with a default-constructed allocator.
2. Overload (2). Constructs an empty basic_stacktrace using alloc as the allocator.
3. Overload (3) — copy constructor. Constructs a basic_stacktrace with the copy of the contents of other; the allocator is obtained as if by calling std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()).
4. Overload (4) — move constructor. Constructs a basic_stacktrace with the contents of other using move semantics. Allocator is move-constructed from that of other. After construction, other is left in a valid but unspecified state.
5. Overload (5). Same as the copy constructor, except that alloc is used as the allocator.
6. Overload (6). Behaves same as the move constructor if alloc == other.get_allocator(). Otherwise, allocates memory with alloc and performs element-wise move. alloc is used as the allocator.

(3,5,6) may throw an exception or construct an empty basic_stacktrace on allocation failure. not me being dramatic about allocation, but that's literally what it says 😭

---

🎀 PARAMETERS 🎀

• alloc — allocator to use for all memory allocations of the constructed basic_stacktrace.
• other — another basic_stacktrace to copy/move from.

---

😭 EXCEPTIONS 😭

• Overload (1). noexcept specification: noexcept(std::is_nothrow_default_constructible_v<allocator_type>)
• Overloads 3, 5, 6. May propagate the exception thrown on allocation failure.

---

⚡ COMPLEXITY ⚡

• 1, 2. Constant.
• 3. Linear in size of other.
• 4. Constant.
• 5. Linear in size of other.
• 6. Linear in size of other if alloc != other.get_allocator(), otherwise constant.

---

📝 NOTES 📝

After container move construction (overload (4)), references, pointers, and iterators (other than the end iterator) to other remain valid, but refer to elements that are now in *this. The current standard makes this guarantee via the blanket statement in [container.reqmts]/67, and a more direct guarantee is under consideration via LWG issue 2321.

---

🍓 EXAMPLE 🍓

This section is incomplete.

Reason: no example.

---

👀 SEE ALSO 👀

• operator= — assigns to the basic_stacktrace (public member function).
• current — obtains the current stacktrace or its given part, [static] (public static member function).

---

🏷️ CATEGORIES 🏷️

• conditionally noexcept
• Todo no example

---

and that's the whole vibe — source/version/date cuteness: http://cppreference.com, 2024.06.10, page std::basic_...c_stacktrace(3). byeee, go construct something iconic 💅✨