std::is_aggregate
From cppreference.com
Defined in header <type_traits>
|
||
template< class T > struct is_aggregate; |
(since C++17) | |
std::is_aggregate
is a UnaryTypeTrait.
If T
is an aggregate type, provides the member constant value
equal true. For any other type, value
is false.
If T
is an incomplete type other than an array type or (possibly cv-qualified) void, the behavior is undefined.
If the program adds specializations for std::is_aggregate
or std::is_aggregate_v
, the behavior is undefined.
Contents |
[edit] Template parameters
T | - | a type to check |
[edit] Helper variable template
template< class T > 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> |
[edit] Notes
Feature-test macro | Value | Std | Feature |
---|---|---|---|
__cpp_lib_is_aggregate |
201703L |
(C++17) | std::is_agregate
|
[edit] Example
Run this code
#include <algorithm> #include <cassert> #include <cstddef> #include <new> #include <string_view> #include <type_traits> #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; }; static_assert(std::is_aggregate_v<A>); struct B { int i; std::string_view str; B(int i, std::string_view str) : i(i), str(str) {} }; static_assert(not std::is_aggregate_v<B>); template <typename... Ts> using aligned_storage_t = alignas(Ts...) std::byte[std::max({sizeof(Ts)...})]; int main() { aligned_storage_t<A, B> storage; A& a = *construct(reinterpret_cast<A*>(&storage), 1, 2); assert(a.x == 1 and a.y == 2); B& b = *construct(reinterpret_cast<B*>(&storage), 3, "4"); assert(b.i == 3 and b.str == "4"); }
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
LWG 3823 | C++17 | The behavior is undefined if T is an array type butstd::remove_all_extents_t<T> is an incomplete type.
|
The behavior is defined regardless of the incompleteness of std::remove_all_extents_t<T> as long as T is an array type.
|