# std::assume_aligned

From cppreference.com
< cpp‎ | memory

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

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

The program is ill-formed if `N` is not 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`.

### Exceptions

Throws nothing.

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

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/assume_aligned&oldid=107417"