Std::is_aggregate (3) Linux Manual Page

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

std::is_aggregate (3) Linux Manual Page