aligned malloc() in GCC?

Is there any standardized function in GCC or glibc to allocate memory block at aligned po开发者_如何学编程inter? Like _align_malloc() in MSVC?

Since the question was asked, a new function was standardized by C11:

void *aligned_alloc(size_t alignment, size_t size);

and it is available in glibc (not on windows as far as I know). It takes its arguments in the same order as memalign, the reverse of Microsoft's _aligned_malloc, and uses the same free function as usual for deallocation.

A subtle difference is that aligned_alloc requires size to be a multiple of alignment.

See the memalign family of functions.

The [posix_memalign()][1] function provides aligned memory allocation and has been available since glibc 2.1.91.

But not necessarily with other compilers: quoting the standard "The posix_memalign() function is part of the Advisory Information option and need not be provided on all implementations."

There are _mm_malloc and _mm_free which are supported by most compilers of the x86/x64 world, with at least:

• gcc
• MinGW (gcc win32/win64)
• MSVC
• clang
• ICC

AFAIK, these functions are not a standard at all. But it is to my knowledge the most supported ones. Other functions are more compiler specific:

• _aligned_malloc is MSVC and MinGW only
• posix memalign functions are not supported by at least MSVC

There are also C11 standard functions but unfortunately they are not in c++11, and including them in c++ require non standard preprocessor defines...

It depends on what kind of alignment you expect. Do you want a stricter alignment, or a more relaxed alignment?

malloc by definition is guaranteed to return a pointer that is properly aligned for storing any standard type in C program (and, therefore, any type built from standard types). Is it what your are looking for? Or do you need something different?

Since C++17 there is standard library function std::aligned_alloc() with signature:

void* aligned_alloc( std::size_t alignment, std::size_t size );

You must #include <cstdlib> to use it. The size parameter must be a multiple of alignment. On failure returns null pointer. Allocated pointer is freed using std::free().

Although not all compilers may have implemented this standard function. For example MSVC didn't implement it for next reason (read here):

MSVC doesn't support the aligned_alloc function. C11 specified aligned_alloc() in a way that's incompatible with the Microsoft implementation of free(), namely, that free() must be able to handle highly aligned allocations.

For MSVC _aligned_malloc() and _aligned_free() must be used.

But GCC/G++ has this standard std::aligned_alloc(), at least I tested this on Windows+Cygwin.