Namespaces
Variants
Views
Actions

std::aligned_storage

From cppreference.com
< cpp‎ | types
Revision as of 17:23, 27 November 2012 by 77.161.51.28 (Talk)

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

Template:ddcl list begin <tr class="t-dsc-header">

<td>
Defined in header <type_traits>
</td>

<td></td> <td></td> <tr class="t-dcl ">

<td >
template< std::size_t Len, std::size_t Align = /*default-alignment*/ >
struct aligned_storage;
</td>

<td class="t-dcl-nopad"> </td> <td > (since C++11) </td> </tr> Template:ddcl list end

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

Member types

Name Definition
type the POD type of at least size Len with alignment requirement Align

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.

Possible implementation

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

template<std::size_t Len, std::size_t Align>
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
{
    // 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(5, '*');
    v1.emplace_back(10, '*');
    std::cout << v1[0] << '\n' << v1[1] << '\n';
}

Output:

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

See also

Template:cpp/language/dcl list alignas
obtains the type's alignment requirements
(class template) [edit]
defines the type suitable for use as uninitialized storage for all given types
(class template) [edit]
POD type with alignment requirement as great as any other scalar type
(typedef) [edit]