std:: is_aggregate

std::is_aggregate est un UnaryTypeTrait .

Si T est un type agrégé , fournit la constante membre value égale à true . Pour tout autre type, value est false .

Si T est un type incomplet autre qu'un type tableau ou (éventuellement qualifié cv) void , le comportement est indéfini.

Si le programme ajoute des spécialisations pour std::is_aggregate ou std::is_aggregate_v , le comportement est indéfini.

Paramètres du modèle

Modèle de variable d'assistance

Notes

Exemple

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <new>
#include <string_view>
#include <type_traits>
#include <utility>
// Construit un T à l'adresse mémoire non initialisée pointée par p en utilisant
// l'initialisation par liste pour les agrégats et l'initialisation non-liste sinon.
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");
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.