std:: aligned_union

Fournit le type imbriqué type , qui est un type trivial à disposition standard d'une taille et d'un alignement adaptés pour être utilisés comme stockage non initialisé pour un objet de l'un des types listés dans Types . La taille du stockage est au moins Len . std::aligned_union détermine également l'exigence d'alignement la plus stricte (la plus grande) parmi tous les Types et la rend disponible sous la forme de la constante alignment_value .

Si sizeof... ( Types ) == 0 ou si l'un des types dans Types n'est pas un type d'objet complet, le comportement est indéfini.

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

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

Types membres

Types auxiliaires

Constantes membres

Implémentation possible

#include <algorithm>
template<std::size_t Len, class... Types>
struct aligned_union
{
    static constexpr std::size_t alignment_value = std::max({alignof(Types)...});
    struct type
    {
        alignas(alignment_value) char _s[std::max({Len, sizeof(Types)...})];
    };
};

` n'a pas été traduit
- Les termes spécifiques au C++ (comme `struct`, `template`, `alignas`, etc.) n'ont pas été traduits
- Le code C++ reste inchangé conformément aux instructions

Exemple

#include <iostream>
#include <string>
#include <type_traits>
int main()
{
    std::cout << sizeof(std::aligned_union_t<0, char>) << ' ' // 1
              << sizeof(std::aligned_union_t<2, char>) << ' ' // 2
              << sizeof(std::aligned_union_t<2, char[3]>) << ' ' // 3 (!)
              << sizeof(std::aligned_union_t<3, char[4]>) << ' ' // 4
              << sizeof(std::aligned_union_t<1, char, int, double>) << ' '    // 8
              << sizeof(std::aligned_union_t<12, char, int, double>) << '\n'; // 16 (!)
    using var_t = std::aligned_union<16, int, std::string>;
    std::cout << "var_t::alignment_value = " << var_t::alignment_value << '\n'
              << "sizeof(var_t::type) = " << sizeof(var_t::type) << '\n';
    var_t::type aligned_storage;
    int* int_ptr = new(&aligned_storage) int(42); // placement new
    std::cout << "*int_ptr = " << *int_ptr << '\n';
    std::string* string_ptr = new(&aligned_storage) std::string("bar");
    std::cout << "*string_ptr = " << *string_ptr << '\n';
    *string_ptr = "baz";
    std::cout << "*string_ptr = " << *string_ptr << '\n';
    string_ptr->~basic_string();
}

1 2 3 4 8 16
var_t::alignment_value = 8
sizeof(var_t::type) = 32
*int_ptr = 42
*string_ptr = bar
*string_ptr = baz

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi