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
. 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
.
Member types
Name | Definition |
---|---|
type | the POD type of at least size Len with alignment requirement Align |
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) |
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.
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 { typedef struct { alignas(Align) unsigned char data[Len]; } type; }; |
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; 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{}; 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 { 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(5, '*'); v1.emplace_back(10, '*'); std::cout << v1[0] << '\n' << v1[1] << '\n'; }
Output:
***** **********
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) |
(C++11) | 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) |
Please login to continue.