# std::aligned_storage

> C++ Atlas: `cppatlas.com/w/cpp/types/aligned_storage` | Source: https://en.cppreference.com/w/cpp/types/aligned_storage | Domain: Type support | Standards: C++11, C++14, C++17, C++23

Provides the nested type type, which satisfies TrivialType and StandardLayoutType and suitable for use as uninitialized storage for any object whose size is at most Len and whose alignment requirement is a divisor of Align.

## Official Specification Summary (cppreference)

```cpp
// Defined in header <type_traits>

template< std::size_t Len, std::size_t Align = /* default-alignment */ >
struct aligned_storage; // (since C++11) (deprecated in C++23)
```

Provides the nested type `type`, which satisfies *TrivialType* and *StandardLayoutType* and 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.

If the program adds specializations for `std::aligned_storage`, the behavior is undefined.

### Member types

**Name — Definition**

- `type`: a trivial and standard-layout type of at least size `Len` with alignment requirement `Align`

### Helper types

```cpp
template< std::size_t Len, std::size_t Align = /* default-alignment */ >
using aligned_storage_t = typename aligned_storage<Len, Align>::type; // (since C++14) (deprecated in C++23)
```

### 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:

```cpp
template<std::size_t Len, std::size_t Align = /* default alignment not implemented */>
struct aligned_storage
{
    struct type
    {
        alignas(Align) unsigned char data[Len];
    };
};
```

### Example

A primitive static vector class, demonstrating creation, access, and destruction of objects in aligned storage.

```cpp
#include <cstddef>
#include <iostream>
#include <new>
#include <string>
#include <type_traits>

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)
    {
        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: std::launder is needed after the change of object model in P0137R1
        return *std::launder(reinterpret_cast<const T*>(&data[pos]));
    }

    // Destroy objects from aligned storage
    ~static_vector()
    {
        for (std::size_t pos = 0; pos < m_size; ++pos)
            // Note: std::launder is needed after the change of object model in P0137R1
            std::destroy_at(std::launder(reinterpret_cast<T*>(&data[pos])));
    }
};

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:

```text
*****
**********
```

### See also

- [`alignas` (C++11)](https://en.cppreference.com/w/cpp/language/alignas): specifies that the storage for the variable should be aligned by specific amount (specifier)
- [`alignment_of`](https://en.cppreference.com/w/cpp/types/alignment_of) (C++11): obtains the type's alignment requirements (class template)
- [`aligned_alloc`](https://en.cppreference.com/w/cpp/memory/c/aligned_alloc) (C++17): allocates aligned memory (function)
- [`aligned_union`](https://en.cppreference.com/w/cpp/types/aligned_union) (since C++11): defines the type suitable for use as uninitialized storage for all given types (class template)
- [`max_align_t`](https://en.cppreference.com/w/cpp/types/max_align_t) (C++11): trivial type with alignment requirement as great as any other scalar type (typedef)
- [`launder`](https://en.cppreference.com/w/cpp/utility/launder) (C++17): pointer optimization barrier (function template)

---
Attribution: content from https://en.cppreference.com/w/cpp/types/aligned_storage (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.