std::align

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

optional, any and variant (C++17)

optional

any

variant

in_placein_place_typein_place_indexin_place_tin_place_type_tin_place_index_t

Pairs and tuples

pair

tuple (C++11)

apply (C++17)

make_from_tuple (C++17)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Elementary string conversions

to_chars (C++17)

from_chars (C++17)

chars_format (C++17)

Type operations

declval (C++11)

as_const (C++17)

 

Dynamic memory management

Smart pointers unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (until C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) Allocators allocator allocator_traits (C++11) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Memory resources pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17)

Uninitialized storage uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) destroy_at (C++17) raw_storage_iterator (deprecated since c++17) get_temporary_buffer (deprecated since c++17) return_temporary_buffer (deprecated since c++17) Garbage collection support declare_reachable (C++11) undeclare_reachable (C++11) declare_no_pointers (C++11) undeclare_no_pointers (C++11) pointer_safety (C++11) get_pointer_safety (C++11) Miscellaneous pointer_traits (C++11) addressof (C++11) align (C++11) C Library malloc aligned_alloc (C++17) calloc realloc free Low level memory management

 

Defined in header <memory>
void* align( std::size_t alignment,              std::size_t size,              void*& ptr,              std::size_t& space );		(since C++11)

Given a pointer ptr to a buffer of size space, returns a pointer aligned by the specified alignment for size number of bytes and decreases space argument by the number of bytes used for alignment. The first aligned address is returned.

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, the function does nothing and returns nullptr.

The behavior is undefined if alignment is not a fundamental or extended alignment value supported by the implementation (until C++17)power of two (since C++17).

Parameters

alignment	-	the desired alignment
size	-	the size of the storage to be aligned
ptr	-	pointer to contiguous storage of at least space bytes
space	-	the size of the buffer in which to operate

Return value

The adjusted value of ptr, or null pointer value if the space provided is too small.

Example

demonstrates the use of std::align to place objects of different type in memory

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;
 
    // allocate a char
    char* p1 = a.aligned_alloc<char>();
    if (p1)
        *p1 = 'a';
    std::cout << "allocated a char at " << (void*)p1 << '\n';
 
    // allocate an int
    int* p2 = a.aligned_alloc<int>();
    if (p2)
        *p2 = 1;
    std::cout << "allocated an int at " << (void*)p2 << '\n';
 
    // allocate an int, aligned at 32-byte boundary
    int* p3 = a.aligned_alloc<int>(32);
    if (p3)
        *p3 = 2;
    std::cout << "allocated an int at " << (void*)p3 << " (32 byte alignment)\n";
}

Possible output:

allocated a char at 0x2ff21a08
allocated an int at 0x2ff21a0c
allocated an int at 0x2ff21a20 (32 byte alignment)

See also

alignof operator	queries alignment requirements of a type (since C++11)
alignas specifier	specifies that the storage for the variable should be aligned by specific amount (C++11)
aligned_storage (C++11)	defines the type suitable for use as uninitialized storage for types of given size (class template)