std::aligned_storage - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# std::aligned_storage

From cppreference.com
< cpp‎ | types

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

Run this code

    #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
        std::aligned_storage_t<sizeof(T), alignof(T)> data[N];
        std::size_t m_size = 0;
    public:

        // Create an object in aligned storage
        template<typename ...Args> void emplace_back(Args&&... args)
        {
            new(data+m_size) T(std::forward<Args>(args)...);
            if( m_size++ >= N ) // possible error handling
                throw std::bad_alloc{};
        }

        // Access an object in aligned storage
        const T& operator[](size_t pos) const
        {
            return *static_cast<const T*>(static_cast<const void*>(&data[pos]));
        }
        // Delete objects from aligned storage
        ~static_vector()
        {
            for(std::size_t pos = 0; pos < m_size; ++pos) {
                static_cast<const T*>(static_cast<const void*>(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';
    }

Output:

    *****
    **********

### [edit] See also

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

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/types/aligned_storage&oldid=72455"