std::is_aggregate (3) - Linux Man Pages

std::is_aggregate: std::is_aggregate


std::is_aggregate - std::is_aggregate


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

Checks if T is an aggregate_type. The member constant value is equal to true if T is an aggregate type and false otherwise.
The behavior is undefined if std::remove_all_extents_t<T> is an incomplete type other than (possibly cv-qualified) void.

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
         (public static member constant)

Member functions

              converts the object to bool, returns value
operator bool (public member function)

operator() returns value
              (public member function)

Member types

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


// Run this code

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

  // constructs a T at the uninitialized memory pointed to by p
  // using list-initialization for aggregates and non-list initialization otherwise
  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::forward<Args>(args)...};
      else {
          return ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);

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

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