std::aligned_storage

From cppreference.com
 
 
 
Type support
Basic types
Fundamental types
Fixed width integer types (C++11)
Numeric limits
numeric_limits
C numeric limits interface
Runtime type information
Type traits
Primary type categories
is_void (C++11)
is_array (C++11)
is_pointer (C++11)
is_enum (C++11)
is_union (C++11)
is_class (C++11)
is_function (C++11)
is_object (C++11)
is_scalar (C++11)
is_compound (C++11)
is_integral (C++11)
is_floating_point (C++11)
is_fundamental (C++11)
is_arithmetic (C++11)
is_reference (C++11)
is_lvalue_reference (C++11)
is_rvalue_reference (C++11)
is_member_pointer (C++11)
is_member_object_pointer (C++11)
is_member_function_pointer (C++11)
Type properties
is_const (C++11)
is_volatile (C++11)
is_pod (C++11)
is_empty (C++11)
is_polymorphic (C++11)
is_abstract (C++11)
Supported operations
is_constructible
is_trivially_constructible
is_nothrow_constructible
(C++11)
(C++11)
(C++11)
is_default_constructible
is_trivially_default_constructible
is_nothrow_default_constructible
(C++11)
(C++11)
(C++11)
is_copy_constructible
is_trivially_copy_constructible
is_nothrow_copy_constructible
(C++11)
(C++11)
(C++11)
is_move_constructible
is_trivially_move_constructible
is_nothrow_move_constructible
(C++11)
(C++11)
(C++11)
is_assignable
is_trivially_assignable
is_nothrow_assignable
(C++11)
(C++11)
(C++11)
is_copy_assignable
is_trivially_copy_assignable
is_nothrow_copy_assignable
(C++11)
(C++11)
(C++11)
is_move_assignable
is_trivially_move_assignable
is_nothrow_move_assignable
(C++11)
(C++11)
(C++11)
is_destructible
is_trivially_destructible
is_nothrow_destructible
(C++11)
(C++11)
(C++11)
has_virtual_destructor (C++11)
Relationships and property queries
is_same (C++11)
is_base_of (C++11)
is_convertible (C++11)
alignment_of (C++11)
rank (C++11)
extent (C++11)
Type modifications
remove_cv
remove_const
remove_volatile
(C++11)
(C++11)
(C++11)
add_cv
add_const
add_volatile
(C++11)
(C++11)
(C++11)
make_signed (C++11)
make_unsigned (C++11)
Type transformations
aligned_storage (C++11)
aligned_union (C++11)
decay (C++11)
enable_if (C++11)
conditional (C++11)
common_type (C++11)
underlying_type (C++11)
result_of (C++11)
Type trait constants
integral_constant (C++11)
 
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 POD type 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 size Len with alignment requirement Align

[edit] Notes

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

[edit] Possible implementation

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

[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
{
    // propertly aligned uninitialized storage for N T's
    typename std::aligned_storage <sizeof(T), std::alignment_of<T>::value>::type data[N];
    std::size_t m_size;
public:
 
    static_vector() : m_size(0) {};
    // Create an object in aligned storage
    template<typename ...Args> void emplace_back(Args&&... args) 
    {
        new(data+m_size) T(std::forward<Args>(args)...);
        m_size++; // bounds check omitted
    }
 
    // Access an object in aligned storage
    const T& operator[](size_t pos) const 
    {
        return reinterpret_cast<const T&>(data[pos]);
    }
    // Delete objects from aligned storage
    ~static_vector() 
    {
        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(std::string(5, '*'));
    v1.emplace_back(std::string(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)