std::is_aggregate - cppreference.com

De cppreference.com


`template< class T > struct is_aggregate;`		(desde C++17)

std::is_aggregate es un UnaryTypeTrait.

Si T es un tipo agregado, proporciona la constante miembro value igual a true. Para cualquier otro tipo, value es false.

El comportamiento no está definido si T es un tipo incompleto distinto de un tipo array o (posiblemente calificado-cv) void.

El comportamiento de un programa que añade especializaciones para is_aggregate o is_aggregate_v no está definido.

Parámetros de plantilla

Plantilla de variable auxiliar

`template< class T > inline constexpr bool is_aggregate_v = is_aggregate<T>::value;`		(desde C++17)

Heredado de std::integral_constant

Constantes miembro

true si T es un tipo agregado, de lo contrario false.
(constante miembro pública estática)

Funciones miembro

	Convierte el objeto a `bool`, devuelve `value`. (función miembro pública)
	Devuelve `value`. (función miembro pública)

Tipos miembro

Tipo	Definición
`value_type`	`bool`
`type`	`std::integral_constant<bool, value>`

Notas

Macro de Prueba de característica	Valor	Estándar	Comentario
`__cpp_lib_is_aggregate`	`201703L`	(C++17)	`std::is_agregate`

Ejemplo

#include <type_traits>
#include <new>
#include <utility>

// construye un objeto T en la memoria sin inicializar a la que apunta p
// usando la inicialización de lista para agregados y
// la inicialización que no es de lista de lo contrario
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, "hola");
}

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 3823	C++17	El comportamiento no está definido si `T` es un tipo array pero `std::remove_all_extents_t<T>` es un tipo incompleto.	El comportamiento se define independientemente de lo incompleto de `std::remove_all_extents_t<T>` siempre y cuando `T` sea un tipo array.