SSttrruuccttss

struct Point {
  double x;
  double y;
};

// ── Initialization ───────────────────────────────────────────
Point a = {1.0, 2.0};          // aggregate init — in declaration order
Point b{3.0, 4.0};             // brace init (C++11) — preferred
Point c = {.x = 1.0, .y = 2.0}; // designated initializers (C++20)
Point d{};                      // zero-initialized: {0.0, 0.0}
Point e;                        // ⚠ members are indeterminate (local struct)

// ── Access ───────────────────────────────────────────────────
a.x = 10.0;
a.y = 20.0;

Point* ptr = &a;
ptr->x;        // 10.0  — arrow operator: dereference + access
(*ptr).x;      // 10.0  — equivalent but more verbose

// ── Struct with default member values (C++11) ────────────────
struct Config {
  int port     = 8080;
  bool ssl     = false;
  std::string host = "localhost";
};
Config cfg;            // all defaults
Config cfg2{9090};     // port=9090, rest default

struct Rectangle {
  double width;
  double height;

  // Member functions — structs can have methods (like classes)
  double area() const {
    return width * height;
  }
  double perimeter() const {
    return 2 * (width + height);
  }

  // Modify members
  void scale(double factor) {
    width  *= factor;
    height *= factor;
  }

  // Static member function — no 'this' pointer
  static Rectangle square(double side) {
    return {side, side};
  }
};

Rectangle r{4.0, 3.0};
r.area();         // 12.0
r.scale(2.0);     // width=8, height=6
Rectangle::square(5.0);   // {5.0, 5.0}

// ── Struct layout — members stored in declaration order ──────
struct Packed {
  char   a;    // 1 byte
  int    b;    // 4 bytes — but starts at offset 4 (3 bytes padding!)
  char   c;    // 1 byte
  // 3 bytes padding at end (struct size must be multiple of alignment)
};
sizeof(Packed);   // 12 — not 6!

// ── Reorder to minimize padding ──────────────────────────────
struct Tight {
  int    b;    // 4 bytes at offset 0
  char   a;    // 1 byte at offset 4
  char   c;    // 1 byte at offset 5
  // 2 bytes padding
};
sizeof(Tight);    // 8 — not 12

// ── alignof — alignment requirement ─────────────────────────
alignof(Packed);  // 4 (int's alignment requirement dominates)

// ── #pragma pack / __attribute__((packed)) — force no padding
// ⚠ Accessing misaligned members is UB on some architectures
struct [[gnu::packed]] Wire { char a; int b; };  // size = 5

struct Vec2 {
  double x, y;

  // Constructor (not needed for aggregates, but adds validation)
  Vec2(double x, double y) : x(x), y(y) {}

  // Copy constructor (compiler generates one automatically)
  Vec2(const Vec2&) = default;

  // Move constructor (C++11)
  Vec2(Vec2&&) = default;

  // Copy assignment
  Vec2& operator=(const Vec2&) = default;

  // Destructor (compiler generates: does nothing for trivial types)
  ~Vec2() = default;

  // Comparison (C++20: default generates == and <=>)
  auto operator<=>(const Vec2&) const = default;

  // Arithmetic
  Vec2 operator+(const Vec2& o) const { return {x+o.x, y+o.y}; }
  Vec2& operator+=(const Vec2& o) { x+=o.x; y+=o.y; return *this; }
};

// Rule of Zero: if you don't manage resources, don't define
// any of the special members — let the compiler generate them

// Aggregate: no user-provided constructors, no private/protected
// non-static members, no virtual functions, no base classes (C++17)
// → supports aggregate initialization and structured bindings

struct Color { uint8_t r, g, b, a = 255; };
Color red   = {255, 0, 0};         // a defaults to 255
Color green = {.r=0,.g=255,.b=0};  // C++20 designated init

// ── Structured bindings decompose aggregates (C++17) ─────────
auto [r, g, b, a] = red;

// ── Returning multiple values — use struct ───────────────────
struct MinMax { int min, max; };

MinMax findMinMax(const std::vector<int>& v) {
  return { *std::min_element(v.begin(),v.end()),
           *std::max_element(v.begin(),v.end()) };
}
auto [lo, hi] = findMinMax(data);

// vs std::pair (less readable field names)
// vs std::tuple (even less readable)
// vs out parameters (awkward call syntax)

//                struct                   class
// Default access  public                   private
// Inheritance     public by default        private by default
// Usage style     data bundles, POD types  encapsulated objects

// ── When to use struct ───────────────────────────────────────
// ✅ Simple data bundles with all public members
// ✅ POD (plain old data) types for C interop, serialization
// ✅ Return-value aggregates (MinMax, ParseResult)
// ✅ Policy/tag types passed as template parameters

// ── When to use class ────────────────────────────────────────
// ✅ Types with invariants to protect (bank account balance)
// ✅ Types that manage resources (file handle, mutex, buffer)
// ✅ Types with significant interface and implementation split

// ── POD (trivial + standard-layout) ─────────────────────────
// Trivial: compiler-generated special members, no virtual functions
// Standard-layout: all members same access, no virtual, C-compatible
#include <type_traits>
std::is_trivial_v<Point>           // true
std::is_standard_layout_v<Point>   // true
std::is_pod_v<Point>               // true (deprecated C++20)