Defined in header <type_traits> | ||
---|---|---|
template< std::size_t Len, std::size_t Align = /*default-alignment*/ > struct aligned_storage; | (since C++11) |
Provides the nested type type
, which is a trivial standard-layout 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
. If the default value is not used, Align
must be the value of alignof(T)
for some type T
, or the behavior is undefined.
The behavior is undefined if Len == 0
.
It is implementation-defined whether any extended alignment is supported.
Name | Definition |
---|---|
type | the POD type of at least size Len with alignment requirement Align |
template< std::size_t Len, std::size_t Align = /*default-alignment*/ > using aligned_storage_t = typename aligned_storage<Len, Align>::type; | (since C++14) |
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.
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]; }; }; |
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; public: // 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{}; // construct value in memory of aligned storage // using inplace operator new new(&data[m_size]) T(std::forward<Args>(args)...); ++m_size; } // Access an object in aligned storage const T& operator[](std::size_t pos) const { // note: needs std::launder as of C++17 return *reinterpret_cast<const T*>(&data[pos]); } // Delete objects from aligned storage ~static_vector() { for(std::size_t pos = 0; pos < m_size; ++pos) { // note: needs std::launder as of C++17 reinterpret_cast<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'; }
Output:
***** **********
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) |
(C++11) | defines the type suitable for use as uninitialized storage for all given types (class template) |
(C++11) | trivial type with alignment requirement as great as any other scalar type (typedef) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/types/aligned_storage