std::aligned_storage

From cppreference.com
< 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
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
Supported operations
Relationships and property queries
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type modifications
(C++11)(C++11)(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
Type transformations
aligned_storage
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
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.

Contents

[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
    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)
(C++11)
obtains the type's alignment requirements
(class template)
defines the type suitable for use as uninitialized storage for all given types
(class template)
(C++11)
POD type with alignment requirement as great as any other scalar type
(typedef)