std::align(3)

💖 NAME 💖

okay so this is the std::align(3) page, from the C++ Standard Libary manual (yes bestie, that spelling is straight from the header, we move 💀). And the name is literally std::align - std::align. That's the whole name. Iconic, concise, no notes.

---

✨ Synopsis ✨

Defined in header <memory>:

void* align( std::size_t alignment,

             std::size_t size,       (since C++11)
             void*& ptr,

             std::size_t& space );

So here's the tea: you give it a pointer ptr to a buffer of size space, and it hands back a pointer aligned by the alignment you asked for, for size number of bytes — and it decreases the space argument by the number of bytes used for alignment. The first aligned address is what gets returned. Periodt. 💅

Real talk: the function modifies the pointer only if it would be possible to fit the wanted number of bytes, aligned by the given alignment, into the buffer. If the buffer is too small? It does nothing and returns nullptr. No drama, just null. 😭

🚨 okay but listen: the behavior is undefined if alignment is not a power of two. Not "oops", not "implementation-defined", literally undefined. Do not play with that, bestie.

---

🎀 Parameters 🎀

• alignment — the desired alignment ✨
• size — the size of the storage to be aligned 📏
• ptr — pointer to contiguous storage (a buffer) of at least space bytes 🫶
• space — the size of the buffer in which to operate 🌸

---

🦋 Return value 🦋

The adjusted value of ptr, or a null pointer value if the space provided is too small. That's it. That's the return value. 💖

---

🌈 Example 🌈

This one demonstrates the use of std::align to place objects of different type in memory. It's giving tiny allocator energy, and honestly? Obsessed. 🧚

Run this code, bestie:

// Run this code

#include <iostream>
#include <memory>

template<std::size_t N>
struct MyAllocator
{
    char data[N];
    void* p;
    std::size_t sz;
    MyAllocator() : p(data), sz(N) {}
    template<typename T>
    T* aligned_alloc(std::size_t a = alignof(T))
    {
        if (std::align(a, sizeof(T), p, sz))
        {
            T* result = reinterpret_cast<T*>(p);
            p = (char*)p + sizeof(T);
            sz -= sizeof(T);
            return result;
        }
        return nullptr;
    }
};

int main()
{
    MyAllocator<64> a;
    std::cout << "allocated a.data at " << (void*)a.data
              << " (" << sizeof a.data << " bytes)\n";

    // allocate a char
    if (char* p = a.aligned_alloc<char>())
    {
        *p = 'a';
        std::cout << "allocated a char at " << (void*)p << '\n';
    }

    // allocate an int
    if (int* p = a.aligned_alloc<int>())
    {
        *p = 1;
        std::cout << "allocated an int at " << (void*)p << '\n';
    }

    // allocate an int, aligned at 32-byte boundary
    if (int* p = a.aligned_alloc<int>(32))
    {
        *p = 2;
        std::cout << "allocated an int at " << (void*)p << " (32 byte alignment)\n";
    }
}

Possible output:

allocated a.data at 0x7ffd0b331f80 (64 bytes)
allocated a char at 0x7ffd0b331f80
allocated an int at 0x7ffd0b331f84
allocated an int at 0x7ffd0b331fa0 (32 byte alignment)

---

🩹 Defect reports 🩹

The following behavior-changing defect reports were applied retroactively to previously published C++ standards. History really said "let's fix that" and we love her for it. 💜

• LWG 2377 — applied to C++11. Behavior as published: alignment required to be a fundamental or supported extended alignment value. Correct behavior: only need to be a power of two. Slay for clearing that up. ✨

---

🔥 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)
• assume_aligned (C++20) — informs the compiler that a pointer is aligned (function template)

---

catch you later, bestie 🫶 this little page came from http://cppreference.com, dated 2024.06.10, and it's the std::align(3) page. bye 💅