std::is_aggregate (3) - Linux Man Pages

std::is_aggregate: std::is_aggregate

NAME

std::is_aggregate - std::is_aggregate

Synopsis


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)
[static]

Member functions


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


operator() returns value
              (public member function)
(C++14)

Member types


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

Example


// 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");
  }