Aggregate Initialisation C++ — Member Reorder Silent Bugs

#include <iostream>
#include <type_traits>
#include <cstdint>

// ============================================================
// AGGREGATE: all public members, no constructors, no virtuals
// Default member initialisers are fine in both C++17 and C++20
// ============================================================
struct Colour {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    uint8_t alpha = 255;  // default member initialiser — still an aggregate
};

// ============================================================
// NOT AN AGGREGATE: has a user-provided constructor
// The constructor body makes this user-provided, not just user-declared
// ============================================================
struct ColourWithCtor {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    ColourWithCtor(uint8_t r, uint8_t g, uint8_t b)
        : red(r), green(g), blue(b) {}  // user-provided — disqualifies in all standards
};

// ============================================================
// NOT AN AGGREGATE: has a private non-static data member
// Any private or protected data member disqualifies the type
// ============================================================
struct SecretColour {
    uint8_t red;
private:
    uint8_t green;  // private — disqualifies regardless of standard version
public:
    uint8_t blue;
};

// ============================================================
// C++17: NOT an aggregate — = default is user-declared
// C++20: IS an aggregate — defaulted ctors no longer disqualify
// Behaviour depends on which standard you compile with
// ============================================================
struct ColourDefaulted {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    ColourDefaulted() = default;  // user-declared, not user-provided
};

// Guard aggregate status so a future change fails loudly at the definition
static_assert(std::is_aggregate_v<Colour>,
    "Colour must remain an aggregate — do not add constructors or private members");

int main() {
    std::cout << std::boolalpha;
    std::cout << "Colour is aggregate:          " << std::is_aggregate_v<Colour>          << "\n";
    std::cout << "ColourWithCtor is aggregate:  " << std::is_aggregate_v<ColourWithCtor>  << "\n";
    std::cout << "SecretColour is aggregate:    " << std::is_aggregate_v<SecretColour>    << "\n";
    // ColourDefaulted: true in C++20, false in C++17
    std::cout << "ColourDefaulted is aggregate: " << std::is_aggregate_v<ColourDefaulted> << "\n";

    // Aggregate initialisation — one line, all fields, no constructor
    Colour skyBlue { 135, 206, 235, 255 };  // positional: red, green, blue, alpha
    std::cout << "\nSky blue RGBA: "
              << static_cast<int>(skyBlue.red)   << ", "
              << static_cast<int>(skyBlue.green) << ", "
              << static_cast<int>(skyBlue.blue)  << ", "
              << static_cast<int>(skyBlue.alpha) << "\n";

    // Partial init — alpha omitted, uses default member initialiser (255)
    Colour opaqueRed { 220, 30, 30 };
    std::cout << "Opaque red alpha: " << static_cast<int>(opaqueRed.alpha) << " (from default init)\n";

    return 0;
}

#include <iostream>
#include <string_view>

// ============================================================
// Nested aggregate: Vec2 is initialised with its own inner braces
// ============================================================
struct Vec2 {
    float x;
    float y;
};

struct Sprite {
    std::string_view  name;
    Vec2              position;    // nested aggregate
    Vec2              scale;       // nested aggregate
    float             rotation;    // degrees
    bool              visible;
    int               zLayer = 0;  // default member initialiser — not zero-init
};

void printSprite(const Sprite& s) {
    std::cout << "[" << s.name << "]\n"
              << "  position : (" << s.position.x << ", " << s.position.y << ")\n"
              << "  scale    : (" << s.scale.x    << ", " << s.scale.y    << ")\n"
              << "  rotation : " << s.rotation << " deg\n"
              << "  visible  : " << std::boolalpha << s.visible << "\n"
              << "  zLayer   : " << s.zLayer << "\n";
}

int main() {
    // ============================================================
    // Full initialisation: every field explicitly provided
    // Inner braces for Vec2 members make the nesting explicit
    // ============================================================
    Sprite player {
        "player_hero",       // name
        { 100.0f, 200.0f }, // position — inner braces for Vec2
        { 1.0f,   1.0f   }, // scale
        0.0f,               // rotation
        true,               // visible
        5                   // zLayer — overrides the default of 0
    };

    // ============================================================
    // Partial initialisation:
    // rotation  -> zero-init (0.0f) — no default member initialiser
    // visible   -> zero-init (false)
    // zLayer    -> default member initialiser (0) — NOT zero-init
    // Result is identical here, but the mechanism differs and matters
    // when the default is non-zero
    // ============================================================
    Sprite backgroundCloud {
        "cloud_01",
        { 300.0f, 50.0f }, // position
        { 2.0f, 1.5f }     // scale — everything after is zero/default
    };

    // ============================================================
    // Array of aggregates: all four waypoints initialised inline
    // No constructor, no loop, no push_back — compile-time layout
    // ============================================================
    Vec2 patrolPath[] = {
        {   0.0f,   0.0f },
        { 150.0f,   0.0f },
        { 150.0f, 150.0f },
        {   0.0f, 150.0f }
    };

    std::cout << "=== Player ===\n";
    printSprite(player);

    std::cout << "\n=== Background Cloud ===\n";
    printSprite(backgroundCloud);

    std::cout << "\nPatrol path waypoints: "
              << (sizeof(patrolPath) / sizeof(Vec2)) << "\n";

    for (std::size_t i = 0; i < sizeof(patrolPath) / sizeof(Vec2); ++i) {
        std::cout << "  [" << i << "] ("
                  << patrolPath[i].x << ", "
                  << patrolPath[i].y << ")\n";
    }

    return 0;
}

#include <iostream>
#include <string_view>
#include <type_traits>

// ============================================================
// Config struct with default member initialisers
// Designated initialisers let callers override only what differs
// from the defaults — the rest uses default member init
// ============================================================
struct ServerConfig {
    std::string_view host           = "localhost";
    uint16_t         port           = 8080;
    int              maxConnections = 100;
    int              timeoutSeconds = 30;
    bool             enableTLS      = false;
    bool             logRequests    = true;
};

static_assert(std::is_aggregate_v<ServerConfig>,
    "ServerConfig must remain an aggregate");

void printConfig(const ServerConfig& cfg) {
    std::cout << "Host            : " << cfg.host            << "\n"
              << "Port            : " << cfg.port            << "\n"
              << "Max connections : " << cfg.maxConnections  << "\n"
              << "Timeout (sec)   : " << cfg.timeoutSeconds  << "\n"
              << "TLS enabled     : " << std::boolalpha << cfg.enableTLS    << "\n"
              << "Log requests    : " << cfg.logRequests     << "\n";
}

int main() {
    // ============================================================
    // Production server: override only the fields that differ from
    // defaults. maxConnections, timeoutSeconds, logRequests all
    // come from their default member initialisers.
    // ============================================================
    ServerConfig productionServer {
        .host      = "api.example.com",
        .port      = 443,
        .enableTLS = true
    };

    // ============================================================
    // Dev server: uses localhost from default, overrides port only
    // ============================================================
    ServerConfig devServer {
        .port        = 3000,
        .logRequests = true
    };

    // ============================================================
    // Compile error — designators must follow declaration order:
    // ServerConfig broken { .port = 9000, .host = "test.com" };
    //   error: designator 'host' does not refer to any field in
    //   type 'ServerConfig' after field 'port'
    // This is the compiler protecting you from the reorder bug
    // ============================================================

    std::cout << "=== Production Server ===\n";
    printConfig(productionServer);

    std::cout << "\n=== Dev Server ===\n";
    printConfig(devServer);

    // ============================================================
    // Designated initialisers with zero-overhead struct creation:
    // No constructor call, no heap allocation, constexpr-compatible
    // ============================================================
    constexpr ServerConfig loopback {
        .host = "127.0.0.1",
        .port = 5432
    };
    std::cout << "\n=== Loopback (constexpr) ===\n";
    printConfig(loopback);

    return 0;
}

#include <iostream>
#include <array>
#include <cassert>
#include <type_traits>

// ============================================================
// AGGREGATE: pure data, no constraints to enforce
// Gets constexpr, C interop, and brace-init for free
// ============================================================
struct Vec3 {
    float x, y, z;

    // Member functions are fine — they don't disqualify aggregate status
    constexpr float lengthSquared() const { return x*x + y*y + z*z; }
    constexpr Vec3 operator+(const Vec3& rhs) const {
        return { x + rhs.x, y + rhs.y, z + rhs.z };
    }
};

static_assert(std::is_aggregate_v<Vec3>);

// ============================================================
// NON-AGGREGATE: enforces a real invariant (must be 0-255)
// Constructor is justified here — without it nothing prevents
// SafeColour(300, -1, 999) from producing garbage
// ============================================================
class SafeColour {
    uint8_t red_, green_, blue_;
public:
    SafeColour(int r, int g, int b) {
        assert(r >= 0 && r <= 255 && "Red out of range");
        assert(g >= 0 && g <= 255 && "Green out of range");
        assert(b >= 0 && b <= 255 && "Blue out of range");
        red_   = static_cast<uint8_t>(r);
        green_ = static_cast<uint8_t>(g);
        blue_  = static_cast<uint8_t>(b);
    }
    void print() const {
        std::cout << "SafeColour("
                  << static_cast<int>(red_)   << ", "
                  << static_cast<int>(green_) << ", "
                  << static_cast<int>(blue_)  << ")\n";
    }
};

// ============================================================
// COMPILE-TIME LOOKUP TABLE via aggregate initialisation
// ShaderConstant is an aggregate — the table lives in rodata,
// no constructor calls, no startup overhead
// ============================================================
struct ShaderConstant {
    const char* name;
    float       value;
    int         bindingSlot;
};

constexpr std::array<ShaderConstant, 3> kDefaultLightingUniforms = {{
    { "u_ambientStrength",  0.1f,  0 },
    { "u_specularPower",   32.0f,  1 },
    { "u_lightIntensity",   1.0f,  2 }
}};

// ============================================================
// C++20 non-type template parameter using an aggregate
// This only works because Vec3 is a structural type (an aggregate)
// ============================================================
template <Vec3 Gravity>
struct PhysicsWorld {
    void printGravity() const {
        std::cout << "Gravity: ("
                  << Gravity.x << ", "
                  << Gravity.y << ", "
                  << Gravity.z << ")\n";
    }
};

int main() {
    // constexpr — fully compile-time, zero runtime cost
    constexpr Vec3 gravity   { 0.0f, -9.81f, 0.0f };
    constexpr Vec3 unitRight { 1.0f,  0.0f,  0.0f };
    constexpr Vec3 sum = gravity + unitRight;

    std::cout << "Gravity Y         : " << gravity.y << "\n";
    std::cout << "Unit right length^2: " << unitRight.lengthSquared() << "\n";
    std::cout << "Sum: (" << sum.x << ", " << sum.y << ", " << sum.z << ")\n";

    SafeColour fireRed(220, 30, 30);
    fireRed.print();

    std::cout << "\nShader uniforms:\n";
    for (const auto& u : kDefaultLightingUniforms) {
        std::cout << "  slot " << u.bindingSlot
                  << " | " << u.name
                  << " = " << u.value << "\n";
    }

    // Aggregate as a non-type template parameter (C++20)
    PhysicsWorld<Vec3{ 0.0f, -9.81f, 0.0f }> earthPhysics;
    earthPhysics.printGravity();

    return 0;
}

#include <iostream>
#include <type_traits>
#include <cstdint>

// ============================================================
// Base aggregate: pure data, no constructors, no virtuals
// Member functions are fine — they don't disqualify aggregate status
// ============================================================
struct EntityBase {
    uint32_t id;
    float    x, y;
    bool     active;

    bool isAt(float px, float py) const {
        return x == px && y == py;
    }
};

// ============================================================
// Derived aggregate (C++17+):
// EntityBase is public, non-virtual, and itself an aggregate
// Player inherits without adding any constructors or virtuals
// ============================================================
struct Player : EntityBase {
    const char* name;
    int         health;
    int         score;
};

// ============================================================
// NOT an aggregate: virtual base disqualifies both the
// base and any type derived from it
// ============================================================
struct VirtualBase {
    virtual void tick() {}
};
struct BadDerived : VirtualBase { int x; };  // not an aggregate

static_assert(std::is_aggregate_v<EntityBase>, "EntityBase must be an aggregate");
static_assert(std::is_aggregate_v<Player>,     "Player must be an aggregate");
static_assert(!std::is_aggregate_v<BadDerived>, "BadDerived must not be an aggregate");

void printPlayer(const Player& p) {
    std::cout << "[id=" << p.id << "] " << p.name
              << " at (" << p.x << ", " << p.y << ")"
              << " | HP: "    << p.health
              << " | Score: " << p.score
              << " | Active: " << std::boolalpha << p.active << "\n";
}

int main() {
    // ============================================================
    // C++17 aggregate init with a base class sub-object:
    // Values 1..4 go to EntityBase (id, x, y, active) in order
    // Values 5..7 go to Player's own members (name, health, score)
    // ============================================================
    Player hero {
        1,           // EntityBase::id
        100.0f,      // EntityBase::x
        200.0f,      // EntityBase::y
        true,        // EntityBase::active
        "Hero",      // Player::name
        100,         // Player::health
        0            // Player::score
    };

    printPlayer(hero);
    std::cout << "Hero at spawn point: " << std::boolalpha << hero.isAt(100.0f, 200.0f) << "\n";

    // ============================================================
    // Partial init — trailing derived members zero/default-init
    // name provided, health and score zero-initialised
    // ============================================================
    Player ghost {
        999,         // id
        0.0f,        // x
        0.0f,        // y
        false,       // active
        "Ghost"      // name — health=0, score=0 from zero-init
    };

    printPlayer(ghost);

    return 0;
}

// io.thecodeforge — c-cpp tutorial

#include <cstdio>
#include <cstring>

struct StringView {
    const char* data;
    size_t length;
};

// What you think happens:
StringView make_view() {
    char buffer[64];
    snprintf(buffer, sizeof(buffer), "sensitive_data");
    return {buffer, strlen(buffer)};  // aggregate init: copies pointer, not data
}

int main() {
    StringView sv = make_view();  // sv.data now dangling
    printf("%.*s\n", (int)sv.length, sv.data);  // undefined behavior
    return 0;
}

// io.thecodeforge — c-cpp tutorial

#include <vector>
#include <print>

struct TimerConfig {
    int interval_ms;
    int retries;
    bool auto_reload;
};

int main() {
    // Pre-C++20 disaster:
    std::vector<int> v{5};    // surprise: {5}, not 5 zeros
    std::println("Size: {}, first: {}", v.size(), v[0]);

    // C++20 designated init: no ambiguity
    TimerConfig cfg{.interval_ms = 1000, .retries = 3, .auto_reload = true};
    std::println("interval: {}, retries: {}", cfg.interval_ms, cfg.retries);

    // Compiler error — wrong designator
    // TimerConfig bad{.timeout = 1000}; // fails to compile
    return 0;
}

// io.thecodeforge — c-cpp tutorial

struct Vec3 {
  double x, y, z;
};

struct Triangle {
  Vec3 a, b, c;
  unsigned color;
};

// No constructor needed — direct member init
constexpr Triangle t1{ {}, {1,0,0}, {0,1,0}, 0xFF0000 };

// C++20: skip fields with designated init
constexpr Triangle t2{ .b = {1,0,0}, .color = 0x00FF00 };

// t2.z is zero, t2.a is zero-initialized; no runtime cost
static_assert(t2.a.x == 0.0 && t2.color == 0x00FF00);

// io.thecodeforge — c-cpp tutorial

struct Config {
  int baud = 115200;
  char parity = 'N';
  int stop_bits = 1;
};

struct Base { int id; };
struct Derived : Base { float gain; };

// Designated init: skip stop_bits, keep default
Config c{ .baud = 9600, .parity = 'E' };

// Nested aggregate (C++17 base support)
Derived d{{42}, 3.14f};  // Base::id=42, Derived::gain=3.14

// Compile-time lookup table
constexpr int fib[] = {1, 1, 2, 3, 5, 8, 13};
static_assert(fib[5] == 8);

#include <iostream>

struct Point {
    int x;
    int y;
    int z;
};

int main() {
    // Designated initializers (C++20)
    Point p = {.x = 1, .y = 2, .z = 3};
    std::cout << p.x << ", " << p.y << ", " << p.z << std::endl;

    // Partial initialization: omitted members are zero-initialized
    Point q = {.x = 10};
    std::cout << q.x << ", " << q.y << ", " << q.z << std::endl;

    return 0;
}

#include <iostream>
#include <memory>

struct Point {
    int x, y, z;
};

int main() {
    // Parenthesized aggregate initialization (C++20)
    Point p(1, 2, 3);
    std::cout << p.x << ", " << p.y << ", " << p.z << std::endl;

    // Works with smart pointers
    auto ptr = std::make_unique<Point>(4, 5, 6);
    std::cout << ptr->x << ", " << ptr->y << ", " << ptr->z << std::endl;

    // std::pair is an aggregate in C++20
    std::pair<int, double> pair(7, 3.14);
    std::cout << pair.first << ", " << pair.second << std::endl;

    return 0;
}

#include <iostream>
#include <stdexcept>

// Aggregate: no user-declared constructors
struct Point {
    int x, y;
};

// Class with user-defined constructor
class Circle {
public:
    Circle(double r) : radius(r) {
        if (r < 0) throw std::invalid_argument("radius must be non-negative");
    }
    double area() const { return 3.14159 * radius * radius; }
private:
    double radius;
};

int main() {
    // Aggregate initialization
    Point p = {1, 2};
    std::cout << p.x << ", " << p.y << std::endl;

    // Constructor initialization
    Circle c(5.0);
    std::cout << c.area() << std::endl;

    // Circle cannot be aggregate-initialized
    // Circle c2 = {5.0}; // Error: not an aggregate

    return 0;
}