home | help 
std::aligned_union(3)	       C++ Standard Libary	   std::aligned_union(3)

NAME
     std::aligned_union - std::aligned_union

Synopsis
	Defined in header <type_traits>
	template< std::size_t Len, class... Types >  (since C++11)
	struct aligned_union;			     (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  com-
     plete object
	type, the behavior is undefined.

	It  is	implementation-defined	whether  any  extended alignment is sup-
     ported.

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

Member types
	Name Definition
	type a trivial and standard-layout type suitable for storage of any type
     from Types

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

Member constants
	alignment_value the strictest alignment requirement of all Types
	[static]	(public static member constant)

Possible implementation
	#include <algorithm>

	template<std::size_t Len, class... Types>
	struct aligned_union
	{
	    static  constexpr  std::size_t  alignment_value  =	 std::max({alig-
     nof(Types)...});

	    struct type
	    {
		alignas(alignment_value)	  char	       _s[std::max({Len,
     sizeof(Types)...})];
	    };
	};

Example
     // Run this 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();
      }

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

	Defect reports

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

	   DR	 Applied to	Behavior as published	      Correct behavior
	LWG  2979  C++11       complete  type was not required requires complete
     types

See also
	alignment_of		     obtains the type's alignment requirements
	(C++11) 		     (class template)
	aligned_storage 	     defines the type suitable for use as unini-
     tialized
	(C++11)(deprecated in C++23) storage for types of given size
				     (class template)

http://cppreference.com 	   2024.06.10		   std::aligned_union(3)
home | help