std:: is_aggregate

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 .

Si T es un tipo incompleto que no sea un tipo array o (posiblemente calificado) void , el comportamiento es indefinido.

Si el programa añade especializaciones para std::is_aggregate o std::is_aggregate_v , el comportamiento no está definido.

Parámetros de plantilla

Plantilla de variable auxiliar

Notas

Ejemplo

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <new>
#include <string_view>
#include <type_traits>
#include <utility>
// Construye un T en la memoria no inicializada apuntada por p usando
// inicialización de lista para agregados e inicialización no-lista en caso 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; };
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");
}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.