Structs, aggregates, and plain data bundles

Understanding Structs, aggregates, and plain data bundles

`struct` and `class` differ in exactly one thing: members and base classes are public by default in a struct. The distinction that actually changes behaviour is whether the type is an aggregate — a class with no user-declared or inherited constructors, no private or protected non-static data members, no virtual functions and no virtual bases. When a type is an aggregate, `Sensor s{...}` calls no constructor at all: the compiler pairs the elements of the brace list with the non-static data members in declaration order and initialises each one directly.

That member-by-member rule explains everything else. Supplying fewer initialisers than there are members is legal: each remaining member uses its default member initialiser if it has one, otherwise it is value-initialised, which means zero for scalars and the default constructor for class members. So `Sensor c{}` gives `channel` the value 0 while `scale` still becomes 1.0. And because the list is checked element by element against each member's type, narrowing is diagnosed: passing 3.5 for an `int` member inside braces is a compile error, where an assignment would have quietly truncated it to 3.

Think of a plain data bundle as a named layout with no invariant to defend. Nothing needs validating on construction, so there is nothing for a constructor to do, and staying an aggregate buys real things: brace and designated initialisation, easy `constexpr` use, and — when every member is trivially copyable — a type you can memcpy or read straight out of a binary buffer. The price is that declaration order becomes part of the public interface, since every positional brace list depends on it, and that adding one convenience constructor takes aggregate initialisation away from every existing call site.

#include <iostream>
#include <string>

struct Sensor {
    std::string id;
    int channel;
    double scale = 1.0;   // default member initialiser; still an aggregate
    bool active;
};

void report(const Sensor& s) {
    std::cout << '[' << s.id << "] ch=" << s.channel
              << " scale=" << s.scale
              << " active=" << s.active << '\n';
}

int main() {
    Sensor a{"temp-1", 3, 0.5, true};  // all four members listed
    Sensor b{"hum-2", 7};              // scale keeps its default, active value-initialised
    Sensor c{};                        // nothing listed at all

    report(a);
    report(b);
    report(c);
}

Worked examples

#include <iostream>

struct Window {
    int width;
    int height;
    bool fullscreen;
    const char* title;
};

int main() {
    Window w{.width = 1280, .height = 720, .title = "editor"};
    std::cout << w.width << 'x' << w.height
              << " fullscreen=" << w.fullscreen
              << " title=" << w.title << '\n';
}

#include <iostream>

struct Point { int x; int y; };
struct Rect  { Point origin; Point size; };

void show(const char* tag, const Rect& r) {
    std::cout << tag << ": origin " << r.origin.x << ',' << r.origin.y
              << "  size " << r.size.x << ',' << r.size.y << '\n';
}

int main() {
    Rect a{{1, 2}, {30, 40}};
    Rect b{3, 4, 50, 60};
    Rect c{{5, 6}};

    show("a", a);
    show("b", b);
    show("c", c);
}

#include <cstddef>
#include <iostream>
#include <string>

struct Split {
    std::string head;
    std::string tail;
};

Split split_at(const std::string& s, std::size_t pos) {
    return {s.substr(0, pos), s.substr(pos)};
}

int main() {
    auto [h, t] = split_at("aggregate", 3);
    std::cout << h << '|' << t << '\n';
    std::cout << split_at("aggregate", 0).tail << '\n';
}

Important notes

Common mistakes

Try it yourself