std::assume_aligned(3)

💅 NAME 💅

std::assume_aligned — std::assume_aligned 💖

Okay so bestie, this is the std::assume_aligned page from the C++ Standard Libary manual (the header literally spells it “Libary”, and we’re keeping that energy 🫶). It’s a C++ standard library function, and it’s here to tell the implementation a little secret about alignment. Slay.

🌸 Synopsis 🌸

Defined in header <memory>
template< std::size_t N, class T >                    (since C++20)
[[nodiscard]] constexpr T* assume_aligned( T* ptr );

Here’s the tea: std::assume_aligned informs the implementation that the object ptr points to is aligned to at least N.

The implementation may use this information to generate more efficient code, but it might only make this assumption if the object is accessed via the return value of assume_aligned.

N must be a power of 2. The behavior is undefined if ptr does not point to an object of type T (ignoring cv-qualification at every level), or if the object’s alignment is not at least N. 💀

🦋 Return value 🦋

ptr.

That’s the whole vibe: it returns ptr right back to you 💅.

✨ Exceptions ✨

Throws nothing. Not one exception, periodt. 🙈

🎀 Notes 🎀

To ensure that the program benefits from the optimizations enabled by assume_aligned, it is important to access the object via its return value:

void f(int* p)
{
    int* p1 = std::assume_aligned<256>(p);
    // Use p1, not p, to ensure benefit from the alignment assumption.
    // However, the program has undefined behavior if p is not aligned
    // regardless of whether p1 is used.
}

It is up to the program to ensure that the alignment assumption actually holds. A call to assume_aligned does not cause the compiler to verify or enforce this. No cap: you have to keep that promise yourself. 🫶

Feature-test macro

• __cpp_lib_assume_aligned — value 201811L, std (C++20), feature std::assume_aligned

🍓 Example 🍓

This section is incomplete.

Reason: no example.

🌈 See also 🌈

• alignof operator(C++11) — queries alignment requirements of a type
• alignas specifier(C++11) — specifies that the storage for the variable should be aligned by specific amount
• aligned_storage (C++11)(deprecated in C++23) — defines the type suitable for use as uninitialized storage for types of given size (class template)
• align (C++11) — aligns a pointer in a buffer (function)
• `[[assume(expression)]](C++23) — specifies that the expression will always evaluate to true at a given point (attribute specifier)

🎀 Category: 🎀

• * Todo no example

---

Kisses from http://cppreference.com, version/date 2024.06.10, signed std::assume_aligned(3) — mwah 💋✨