std:: aligned_storage

Proporciona el tipo anidado type , que satisface TrivialType y StandardLayoutType y es adecuado para usar como almacenamiento no inicializado para cualquier objeto cuyo tamaño sea como máximo Len y cuyo requisito de alineación sea un divisor de Align .

El valor predeterminado de Align es el requisito de alineación más estricto (el mayor) para cualquier objeto cuyo tamaño sea como máximo Len . Si no se utiliza el valor predeterminado, Align debe ser el valor de alignof ( T ) para algún tipo T , o el comportamiento es indefinido.

El comportamiento es indefinido si Len == 0 .

Está definido por la implementación si se admite cualquier alineación extendida .

Si el programa añade especializaciones para std::aligned_storage , el comportamiento no está definido.

Tipos de miembros

Tipos auxiliares

Notas

El tipo definido por std::aligned_storage<>::type puede utilizarse para crear bloques de memoria no inicializados adecuados para contener objetos de un tipo dado, opcionalmente alineados de manera más estricta que su requisito de alineación natural, por ejemplo en un límite de caché o de página.

Al igual que con cualquier otro almacenamiento no inicializado, los objetos se crean utilizando placement new y se destruyen con llamadas explícitas al destructor.

Implementación posible

Excepto para el argumento predeterminado, aligned_storage es expresable en términos de 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];
    };
};

Ejemplo

#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';
}

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

Véase también