std:: is_aggregate

std::is_aggregate ist ein UnaryTypeTrait .

Falls T ein Aggregattyp ist, liefert die Memberkonstante value den Wert true . Für jeden anderen Typ ist value false .

Wenn T ein unvollständiger Typ ist, außer einem Array-Typ oder (möglicherweise cv-qualifiziertem) void , ist das Verhalten undefiniert.

Wenn das Programm Spezialisierungen für std::is_aggregate oder std::is_aggregate_v hinzufügt, ist das Verhalten undefiniert.

Template-Parameter

Hilfsvariablen-Template

Hinweise

Beispiel

#include <algorithm>
#include <cassert>
#include <cstddef>
#include <new>
#include <string_view>
#include <type_traits>
#include <utility>
// Konstruiert ein T an der nicht initialisierten Speicheradresse p mittels
// Listeninitialisierung für Aggregate und Nicht-Listen-Initialisierung sonst.
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");
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.