std::is_aggregate(3)

💖 NAME 💖

okay so bestie, this is std::is_aggregate — the whole NAME section is literally std::is_aggregate - std::is_aggregate, and that's iconic. We're in the C++ Standard Libary manual, page std::is_aggregate(3), and yes I'm obsessed. It's giving "we check if a type is an aggregate" energy. periodt. 💅

✨ Synopsis ✨

Defined in header <type_traits> — exact, don't forget it:

Defined in header <type_traits>
template< class T >              (since C++17)
struct is_aggregate;

std::is_aggregate is a UnaryTypeTrait. No cap.

If T is an aggregate type, it provides the member constant value equal true. For any other type, value is false. Slay.

⚠️ if T is an incomplete type other than an array type or (possibly cv-qualified) void, the behavior is undefined. That's UB, bestie — not the cute kind. 😭

🚨 if the program adds specializations for std::is_aggregate or std::is_aggregate_v, the behavior is undefined. Do not do that. Not today. Not ever. 💀

🌸 Template parameters 🌸

• T — a type to check. That's the whole job, lowkey.

🎀 Helper variable template 🎀

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

💫 Inherited from std::integral_constant 💫

🌈 Member constants 🌈

• value — true if T is an aggregate type, false otherwise. [static] (public static member constant).

🦋 Member functions 🦋

• operator bool — converts the object to bool, returns value (public member function).
• operator() — returns value (C++14) (public member function).

🍓 Member types 🍓

• value_type — bool
• type — std::integral_constant<bool, value>

💅 Notes 💅

Feature-test macro situation, iykyk:

• Feature-test macro: __cpp_lib_is_aggregate — Value: 201703L — Std: (C++17) — Feature: std::is_agregate

🔥 Example 🔥

// Run this code — go off, bestie:

#include <new>
#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; };
struct B { B(int, const char*) {} };

int main()
{
    std::aligned_union_t<1, A, B> storage;
    [[maybe_unused]] A* a = construct(reinterpret_cast<A*>(&storage), 1, 2);
    [[maybe_unused]] B* b = construct(reinterpret_cast<B*>(&storage), 1, "hello");
}

💀 Defect reports 💀

The following behavior-changing defect reports were applied retroactively to previously published C++ standards. History lesson, but make it fashion. ✨

• DR LWG 3823, applied to C++17 — Behavior as published: "The behavior is undefined if T is an array type but std::remove_all_extents_t<T> is an incomplete type." Correct behavior: "The behavior is defined regardless of the incompleteness of std::remove_all_extents_t<T> as long as T is an array type."

---

okay bye bestie 🫶 this came from source http://cppreference.com, version/date 2024.06.10, and it's the std::is_aggregate(3) page signing off. mwah 💋🎀