std::aligned_union - cppreference.com (original) (raw)

| | | | | ------------------------------------------------------------------------------------- | | ----------------------------------- | | template< std::size_t Len, class... Types > struct aligned_union; | | (since C++11) (deprecated in C++23) |

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

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

It is implementation-defined whether any extended alignment is supported.

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

Contents

• 1 Member types
• 2 Helper types
• 3 Member constants
• 4 Possible implementation
• 5 Example
• 6 Defect reports
• 7 See also

[edit] Member types

[edit] Helper types

| template< std::size_t Len, class... Types > using aligned_union_t = typename aligned_union<Len,Types...>::type; | | (since C++14) (deprecated in C++23) | | --------------------------------------------------------------------------------------------------------------------------------------- | | ----------------------------------- |

[edit] Member constants

| | the strictest alignment requirement of all Types (public static member constant) | | ----------------------------------------------------------------------------------- |

[edit] Possible implementation

#include   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)...})]; }; };

[edit] Example

#include #include #include   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(); }

Possible 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

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

| | obtains the type's alignment requirements (class template) [edit] | | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | (since C++11)(deprecated in C++23) | defines the type suitable for use as uninitialized storage for types of given size (class template) [edit] |