< cpp‎ | types
Type support
Basic types
Fundamental types
Fixed width integer types (C++11)
Numeric limits
C numeric limits interface
Runtime type information
Type traits
Primary type categories
Type properties
Supported operations
Relationships and property queries
Type modifications
Type transformations
Type trait constants
Defined in header <type_traits>
template< std::size_t Len, std::size_t Align = /*default-alignment*/ >
struct aligned_storage;
(since C++11)

Provides the member typedef type, which is a PODType suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment requirement is a divisor of Align. The default value of Align is the most stringent (the largest) alignment requirement for any object whose size is at most Len.


[edit] Member types

Name Definition
type the POD type of at least size Len with alignment requirement Align

[edit] Helper types

template< std::size_t Len, std::size_t Align = /*default-alignment*/ >
using aligned_storage_t = typename aligned_storage<Len, Align>::type;
(since C++14)

[edit] Notes

The type defined by std::aligned_storage<>::type can be used to create uninitialized memory blocks suitable to hold the objects of given type, optionally aligned stricter than their natural alignment requirement, for example on a cache or page boundary.

As with any other uninitialized storage, the objects are created using placement new and destroyed with explicit destructor calls.

[edit] Possible implementation

Except for default argument, aligned_storage is expressible in terms of alignas:

template<std::size_t Len, std::size_t Align /* default alignment not implemented */>
struct aligned_storage {
    struct type {
        alignas(Align) unsigned char data[Len];

[edit] Example

A primitive static vector class, demonstrating creation, access, and destruction of objects in aligned storage

#include <iostream>
#include <type_traits>
#include <string>
template<class T, std::size_t N>
class static_vector
    // properly aligned uninitialized storage for N T's
    typename std::aligned_storage<sizeof(T), alignof(T)>::type data[N];
    std::size_t m_size = 0;
    // Create an object in aligned storage
    template<typename ...Args> void emplace_back(Args&&... args) 
        if( m_size >= N ) // possible error handling
            throw std::bad_alloc{};
        new(data+m_size) T(std::forward<Args>(args)...);
    // Access an object in aligned storage
    const T& operator[](std::size_t pos) const 
        return *reinterpret_cast<const T*>(data+pos);
    // Delete objects from aligned storage
        for(std::size_t pos = 0; pos < m_size; ++pos) {
            reinterpret_cast<const T*>(data+pos)->~T();
int main()
    static_vector<std::string, 10> v1;
    v1.emplace_back(5, '*');
    v1.emplace_back(10, '*');
    std::cout << v1[0] << '\n' << v1[1] << '\n';



[edit] See also

alignas specifier specifies that the storage for the variable should be aligned by specific amount (C++11) [edit]
obtains the type's alignment requirements
(class template) [edit]
defines the type suitable for use as uninitialized storage for all given types
(class template) [edit]
POD type with alignment requirement as great as any other scalar type
(typedef) [edit]