SysTutorials

Linux Manual Pages › Section 3

stdis_aggregate(3)

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