How to check if a pointer points to a properly aligned memory location?

Question

Given a void * to some storage, how to check whether it points to properly aligned storage without any implementation defined behavior?

Of course we have std::align, but is there a more effective way to do this?

template <std::size_t alignment> inline bool is_aligned(void * ptr) noexcept {     std::size_t max = 1u;     return std::align(alignment, 1u, ptr, max); } 

PS: I need to do this in a C++ standards-compatible fashion, without relying on any platform-specific (implementation defined) hacks.

PPS: I apologize for my (comprehension of) English, its not my native language.

---

EDIT (2018.08.24): Removed "effective" from the title, added even more wording to emphasize that I don't want any implementation defined or platform-specific behavior.

Answer 1

If the remainder isn't zero when dividing the address with the desired alignment, then the address isn't aligned.

inline bool is_aligned(const void * ptr, std::uintptr_t alignment) noexcept {     auto iptr = reinterpret_cast<std::uintptr_t>(ptr);     return !(iptr % alignment); } 

Ths can't be constexpr though, because of the cast.

Also, this relies on the implementation-defined fact that the conversion from pointer to integer must preserve the numeric representation of the address. As pointed out by the comments, that is not guaranteed by the standard, so this function is not necessarily portable to all platforms. That is also true, because it is optional for the implementation to provide std::uintptr_t.

---

I would expect this to only be needed when aligning for a type, so this might be more convenient:

template<class T> bool is_aligned(const void * ptr) noexcept {     auto iptr = reinterpret_cast<std::uintptr_t>(ptr);     return !(iptr % alignof(T)); }