# std::is_aggregate

From cppreference.com
< cpp‎ | types

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

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 > inline constexpr bool is_aggregate_v = is_aggregate<T>::value; |  | (since C++17)

## Inherited from std::integral_constant

### Member constants

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

### Member functions

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

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

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/is_aggregate&oldid=105513"