Structures & Unions

Padding, alignment, and sizeof

• Compilers insert padding so members sit on preferred alignment boundaries.
• Reorder members (largest alignment first, or pack related fields) to sometimes shrink sizeof.
• Never assume a fixed layout across compilers/ABIs without checking — important for binary file formats and networking.
• #pragma pack / attributes can change packing — use sparingly and portably.

Tagged unions (safe union pattern)

• Pair a union with an enum tag that records which member is active.
• This is the classic “discriminated union” pattern — std::variant automates it.

#include <iostream>
using namespace std;

enum class Kind { Int, Float };

struct Tagged {
    Kind k;
    union {
        int i;
        float f;
    };
};

int main() {
    Tagged t{Kind::Int, {}};
    t.i = 10;
    if (t.k == Kind::Int) cout << t.i << "\n";
    return 0;
}

std::variant — modern alternative

• std::variant holds one of several types safely.
• Use std::get, std::holds_alternative, or std::visit.
• Prefer variant over raw union when types have constructors/destructors.

#include <iostream>
#include <variant>
#include <string>
using namespace std;

int main() {
    variant<int, float, string> v = 42;
    cout << get<int>(v) << "\n";
    v = string("hello");
    cout << get<string>(v) << "\n";
    return 0;
}

Student structure demo

#include <iostream>
#include <string>
using namespace std;

struct Student {
    int roll;
    string name;
    float marks;
};

int main() {
    Student s{10, "Neha", 88.0f};
    cout << s.roll << " " << s.name << " " << s.marks << "\n";
    return 0;
}

sizeof struct vs union

#include <iostream>
using namespace std;

struct S { int a; float b; char c; };
union U { int a; float b; char c; };

int main() {
    cout << "sizeof(S) = " << sizeof(S) << "\n";
    cout << "sizeof(U) = " << sizeof(U) << "\n";
    return 0;
}

Union overlay demo

#include <iostream>
using namespace std;

union Number {
    int i;
    float f;
};

int main() {
    Number n{};
    n.i = 10;
    cout << n.i << "\n";
    n.f = 2.5f;
    cout << n.f << "\n";
    cout << "sizeof = " << sizeof(n) << "\n";
    return 0;
}

Array of structures

#include <iostream>
#include <string>
using namespace std;

struct Item {
    string name;
    int qty;
};

int main() {
    Item cart[3] = {{"Pen", 2}, {"Book", 1}, {"Bag", 3}};
    for (const Item& it : cart)
        cout << it.name << " x" << it.qty << "\n";
    return 0;
}

Nested structure — Employee

#include <iostream>
#include <string>
using namespace std;

struct Address { string city; int pin; };
struct Employee { int id; string name; Address addr; };

int main() {
    Employee e{7, "Kiran", {"Pune", 411001}};
    cout << e.name << ", " << e.addr.city << "-" << e.addr.pin << "\n";
    return 0;
}

Tagged union pattern

#include <iostream>
using namespace std;

enum class Type { Int, Float };
struct Value {
    Type t;
    union { int i; float f; };
};

int main() {
    Value v{Type::Float, {}};
    v.f = 9.81f;
    if (v.t == Type::Float) cout << v.f << "\n";
    return 0;
}

std::variant alternative

#include <iostream>
#include <variant>
using namespace std;

int main() {
    variant<int, double> v = 3.14;
    if (holds_alternative<double>(v))
        cout << get<double>(v) << "\n";
    return 0;
}