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

NAME
     std::is_aggregate - std::is_aggregate

Synopsis
	Defined in header <type_traits>
	template< class T >		 (since C++17)
	struct is_aggregate;

	std::is_aggregate is a UnaryTypeTrait.

	If  T  is  an  aggregate  type, provides the member constant value equal
     true. For any
	other type, value is false.

	If T is an incomplete type other than an array	type  or  (possibly  cv-
     qualified) void,
	the behavior is undefined.

	If the program adds specializations for std::is_aggregate or std::is_ag-
     gregate_v,
	the behavior is undefined.

Template parameters
	T - a type to check

	Helper variable template

	template<  class  T >						  (since
     C++17)
	inline constexpr bool is_aggregate_v = is_aggregate<T>::value;

     Inherited from std::integral_constant

Member constants
	value	 true if T is an aggregate type, false otherwise
	[static] (public static member constant)

Member functions
	operator bool converts the object to bool, returns value
		      (public member function)
	operator()    returns value
	(C++14)       (public member function)

Member types
	Type	   Definition
	value_type bool
	type	   std::integral_constant<bool, value>

Notes
	  Feature-test macro	Value	 Std	   Feature
	__cpp_lib_is_aggregate 201703L (C++17) std::is_agregate

Example
     // Run this code

      #include <new>
      #include <type_traits>
      #include <utility>

      // constructs a T at the uninitialized memory pointed to by p using
      // list-initialization for aggregates and non-list  initialization  other-
     wise
      template<class T, class... Args>
      T* construct(T* p, Args&&... args)
      {
	  if constexpr (std::is_aggregate_v<T>)
	      return	   ::new       (static_cast<void*>(p))	     T{std::for-
     ward<Args>(args)...};
	  else
	      return	   ::new       (static_cast<void*>(p))	     T(std::for-
     ward<Args>(args)...);
      }

      struct A { int x, y; };
      struct B { B(int, const char*) {} };

      int main()
      {
	  std::aligned_union_t<1, A, B> storage;
	  [[maybe_unused]]  A*	a = construct(reinterpret_cast<A*>(&storage), 1,
     2);
	  [[maybe_unused]] B* b =  construct(reinterpret_cast<B*>(&storage),  1,
     "hello");
      }

	Defect reports

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

	 DR   Applied	      Behavior as published		    Correct  be-
     havior
		to
		      The behavior is undefined if T is an   The behavior is de-
     fined
	LWG	      array type but			     regardless of the
	3823  C++17   std::remove_all_extents_t<T> is an     incompleteness of
		      incomplete type.			     std::remove_all_ex-
     tents_t<T>
							     as  long as T is an
     array type.

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