std::construct_at(3)

💖 std::construct_at 💖

okay bestie, this page is from the C++ Standard Libary (yes, that's literally how it's spelled up there, we are not fixing it 💅), and it's all about std::construct_at. It's giving "put a brand-new object exactly here" energy, and honestly? Iconic. ✨

🌸 NAME 🌸

std::construct_at — std::construct_at. That's the name. That's the whole name. We love a self-referential main character moment. 👑

🦋 Synopsis 🦋

Defined in header <memory>
template< class T, class... Args >                  (since C++20)
constexpr T* construct_at( T* p, Args&&... args );

Creates a T object initialized with arguments args... at given address p.

Specialization of this function template participates in overload resolution only if ::new(std::declval<void*>()) T(std::declval<Args>()...) is well-formed in an unevaluated context.

Equivalent to:

return ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);

except that construct_at may be used in evaluation of constant expressions.

When construct_at is called in the evaluation of some constant expression e, the argument p must point to either storage obtained by std::allocator<T>::allocate or an object whose lifetime began within the evaluation of e. That's a real rule, bestie — don't skip it. 🫶

🎀 Parameters 🎀

• p — pointer to the uninitialized storage on which a T object will be constructed
• args... — arguments used for initialization

🌈 Return value 🌈

p

Yep, it hands you back the pointer. Simple, clean, slay. 💅

🔥 Example 🔥

       // Run this code

        #include <bit>
        #include <memory>

        class S
        {
            int x_;
            float y_;
            double z_;
        public:
            constexpr S(int x, float y, double z) : x_{x}, y_{y}, z_{z} {}
            [[nodiscard("no side-effects!")]]
            constexpr bool operator==(const S&) const noexcept = default;
        };

        consteval bool test()
        {
            alignas(S) unsigned char storage[sizeof(S)]{};
            S uninitialized = std::bit_cast<S>(storage);
            std::destroy_at(&uninitialized);
            S* ptr = std::construct_at(std::addressof(uninitialized), 42,
       2.71f, 3.14);
            const bool res{*ptr == S{42, 2.71f, 3.14}};
            std::destroy_at(ptr);
            return res;
        }
        static_assert(test());

        int main() {}

🩹 Defect reports 🩹

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

• DR: LWG 3870
  • Applied to: C++20
  • Behavior as published: construct_at could create objects of a cv-qualified types
  • Correct behavior: only cv-unqualified types are permitted

👑 See also 👑

• allocate — allocates uninitialized storage (public member function of std::allocator<T>)
• construct [static] — constructs an object in the allocated storage (function template)
• destroy_at (C++17) — destroys an object at a given address (function template)
• ranges::construct_at (C++20) — creates an object at a given address (niebloid)

---

that's the whole vibe check, bestie. this page came from http://cppreference.com, dated 2024.06.10 💌✨