View source for cpp/types/aligned union

{{cpp/title|aligned_union}}
{{cpp/meta/navbar}}
{{dcl begin}}
{{dcl header|type_traits}}
{{dcl|since=c++11|deprecated=c++23|1=
template< std::size_t Len, class... Types >
struct aligned_union;
}}
{{dcl end}}

Provides the nested type {{tt|type}}, which is a [[cpp/named req/TrivialType|trivial]] [[cpp/named req/StandardLayoutType|standard-layout]] type of a size and alignment suitable for use as uninitialized storage for an object of any of the types listed in {{tt|Types}}. The size of the storage is at least {{tt|Len}}. {{tt|std::aligned_union}} also determines the strictest (largest) alignment requirement among all {{tt|Types}} and makes it available as the constant {{tt|alignment_value}}.

If {{c|1=sizeof...(Types) == 0}} or if any of the types in {{tt|Types}} is not a complete object type, the behavior is undefined.

It is implementation-defined whether any [[cpp/language/object#Alignment|extended alignment]] is supported.

{{cpp/types/nospec}}

===Member types===
{{dsc begin}}
{{dsc hitem|Name|Definition}}
{{dsc|{{tt|type}}|a trivial and standard-layout type suitable for storage of any type from {{tt|Types}}}}
{{dsc end}}

===Helper types===
{{dcl begin}}
{{dcl|since=c++14|deprecated=c++23|1=
template< std::size_t Len, class... Types >
using aligned_union_t = typename aligned_union<Len,Types...>::type;
}}
{{dcl end}}

===Member constants===
{{dsc begin}}
{{dsc mem sconst|alignment_value|the strictest alignment requirement of all {{tt|Types}}|nolink=true}}
{{dsc end}}

===Possible implementation===
{{eq fun|1=
#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)...})];
    };
};
}}

===Example===
{{example
|code=
#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();
}
|p=true <!-- sizeof(std::string) is unspecified -->
|output=
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
}}

===Defect reports===
{{dr list begin}}
{{dr list item|wg=lwg|dr=2979|std=C++11|before=complete type was not required|after=requires complete types}}
{{dr list end}}

===See also===
{{dsc begin}}
{{dsc inc|cpp/types/dsc alignment_of}}
{{dsc inc|cpp/types/dsc aligned_storage}}
{{dsc end}}

{{langlinks|de|es|fr|it|ja|pt|ru|zh}}