Aggregate Initialisation in C++: The Complete Guide With Real-World Examples

#include <iostream>
#include <type_traits>

// --- This IS an aggregate (C++20 and later) ---
struct Colour {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    uint8_t alpha = 255;  // default member initialisers are fine
};

// --- This is NOT an aggregate: has a user-provided constructor ---
struct ColourWithCtor {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    ColourWithCtor(uint8_t r, uint8_t g, uint8_t b) // user-PROVIDED ctor
        : red(r), green(g), blue(b) {}
};

// --- This is NOT an aggregate: has a private member ---
struct SecretColour {
    uint8_t red;
private:
    uint8_t green;  // private — disqualifies the type
public:
    uint8_t blue;
};

int main() {
    // std::is_aggregate_v is available from C++17 — great for static_asserts
    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";

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

    return 0;
}

#include <iostream>
#include <string_view>

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
};

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 explicit initialisation — every field spelled out
    Sprite player {
        "player_hero",   // name
        { 100.0f, 200.0f }, // position — nested brace for Vec2
        { 1.0f,   1.0f   }, // scale
        0.0f,               // rotation
        true,               // visible
        5                   // zLayer (overrides default of 0)
    };

    // Partial initialisation — trailing members get zero-init or their defaults
    // rotation=0.0, visible=false (zero-init), zLayer=0 (default member init)
    Sprite backgroundCloud {
        "cloud_01",
        { 300.0f, 50.0f }, // position
        { 2.0f, 1.5f }     // scale — everything after this is zero/default
    };

    // Array of aggregates — all initialised inline
    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 has " << (sizeof(patrolPath) / sizeof(Vec2)) << " waypoints\n";

    return 0;
}

#include <iostream>
#include <string>

struct ServerConfig {
    std::string host          = "localhost";
    uint16_t    port          = 8080;
    int         maxConnections = 100;
    int         timeoutSeconds = 30;
    bool        enableTLS     = false;
    bool        logRequests   = true;
};

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() {
    // --- C++20 Designated Initialisers ---
    // Only override what differs from defaults — everything else uses the struct's defaults
    // This reads like configuration code, not a mystery list of values
    ServerConfig productionServer {
        .host    = "api.example.com",
        .port    = 443,
        .enableTLS  = true
        // maxConnections=100, timeoutSeconds=30, logRequests=true come from defaults
    };

    ServerConfig devServer {
        .port         = 3000,        // just change the port
        .logRequests  = true         // explicit for clarity
        // host="localhost" from default — zero config for local dev
    };

    // You can also do this at namespace scope — truly compile-time constant config
    // (constexpr requires literal types, string_view instead of std::string)

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

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

    // Demonstrating that order must match declaration order
    // This would be a COMPILE ERROR — .port comes before .host in the struct
    // ServerConfig broken { .port = 9000, .host = "test.com" };  // ERROR!

    return 0;
}

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

// --- AGGREGATE: pure data, no invariants, use brace-init ---
struct Vec3 {
    float x, y, z;

    // Free functions handle behaviour — the struct stays a simple aggregate
    float lengthSquared() const { return x*x + y*y + z*z; }
};

// --- NON-AGGREGATE: has an invariant (red/green/blue must be 0-255) ---
class SafeColour {
    uint8_t red_, green_, blue_;
public:
    // Constructor is justified here — we're enforcing an invariant
    SafeColour(int r, int g, int b) {
        assert(r >= 0 && r <= 255 && "Red channel out of range");
        assert(g >= 0 && g <= 255 && "Green channel out of range");
        assert(b >= 0 && b <= 255 && "Blue channel 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 << "Colour(" << (int)red_ << ", " << (int)green_ << ", " << (int)blue_ << ")\n";
    }
};

// Aggregate initialisation enables constexpr lookup tables with zero boilerplate
struct ShaderConstant {
    const char* name;
    float       value;
    int         bindingSlot;
};

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

int main() {
    // Vec3 as aggregate: clear, fast, constexpr-compatible
    constexpr Vec3 gravity  { 0.0f, -9.81f, 0.0f };
    constexpr Vec3 unitRight { 1.0f,  0.0f,  0.0f };

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

    // SafeColour: constructor is the right tool — it guards the invariant
    SafeColour fireRed(220, 30, 30);
    fireRed.print();

    // Print compile-time shader uniform table
    std::cout << "\nShader uniforms:\n";
    for (const auto& uniform : defaultLightingUniforms) {
        std::cout << "  slot " << uniform.bindingSlot
                  << " | " << uniform.name
                  << " = " << uniform.value << "\n";
    }

    return 0;
}