std:: aligned_storage

Fournit le type imbriqué type , qui satisfait TrivialType et StandardLayoutType et convient comme stockage non initialisé pour tout objet dont la taille est au plus Len et dont l' exigence d'alignement est un diviseur de Align .

La valeur par défaut de Align est l'exigence d'alignement la plus stricte (la plus grande) pour tout objet dont la taille est au plus Len . Si la valeur par défaut n'est pas utilisée, Align doit être la valeur de alignof ( T ) pour un certain type T , sinon le comportement est indéfini.

Le comportement est indéfini si Len == 0 .

Il est défini par l'implémentation si un alignement étendu est pris en charge.

Si le programme ajoute des spécialisations pour std::aligned_storage , le comportement est indéfini.

Types membres

Types auxiliaires

Notes

Le type défini par std::aligned_storage<>::type peut être utilisé pour créer des blocs de mémoire non initialisés adaptés à contenir des objets d'un type donné, optionnellement alignés plus strictement que leur alignement naturel requis, par exemple sur une limite de cache ou de page.

Comme pour tout autre stockage non initialisé, les objets sont créés en utilisant placement new et détruits avec des appels explicites au destructeur.

Implémentation possible

Sauf pour l'argument par défaut, aligned_storage est exprimable en termes de alignas :

template<std::size_t Len, std::size_t Align = /* alignement par défaut non implémenté */>
struct aligned_storage
{
    struct type
    {
        alignas(Align) unsigned char data[Len];
    };
};

Exemple

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

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

Voir aussi