Structures and Unions in C Explained — Memory, Use Cases and Pitfalls

#include <stdio.h>
#include <string.h>

// Define a struct that models a game player.
// Every field gets its OWN memory slot — all exist at the same time.
typedef struct {
    char  username[32];  // 32 bytes
    int   health;        // 4 bytes (likely padded to align next field)
    float position_x;   // 4 bytes
    float position_y;   // 4 bytes
    int   score;         // 4 bytes
} Player;

// Function that accepts a Player by VALUE (a copy is made)
void print_player_status(Player p) {
    printf("--- Player Status ---\n");
    printf("Username : %s\n",  p.username);
    printf("Health   : %d\n",  p.health);
    printf("Position : (%.1f, %.1f)\n", p.position_x, p.position_y);
    printf("Score    : %d\n",  p.score);
}

// Function that accepts a POINTER to Player — modifies original, no copy overhead
void apply_damage(Player *p, int damage_amount) {
    p->health -= damage_amount;  // Arrow operator dereferences pointer AND accesses member
    if (p->health < 0) {
        p->health = 0;           // Clamp health to zero — no negative health
    }
}

int main(void) {
    // Initialise a Player using designated initialisers (C99+)
    // Any field not listed is zero-initialised automatically
    Player hero = {
        .username   = "Aria_Stormblade",
        .health     = 100,
        .position_x = 12.5f,
        .position_y = 7.0f,
        .score      = 0
    };

    print_player_status(hero);

    // Apply damage via pointer — mutates the original struct
    apply_damage(&hero, 35);
    hero.score += 500;  // Direct member access with dot operator

    printf("\nAfter combat:\n");
    print_player_status(hero);

    // See how much memory the struct actually occupies
    printf("\nsizeof(Player) = %zu bytes\n", sizeof(Player));
    // Individual fields sum to: 32 + 4 + 4 + 4 + 4 = 48 bytes
    // Actual size may match or exceed this due to alignment padding

    return 0;
}

#include <stdio.h>
#include <stddef.h>  // for offsetof macro

// BAD layout: fields ordered in a way that wastes memory via padding
typedef struct {
    char   is_active;    // 1 byte at offset 0
                         // 3 bytes of PADDING inserted here by compiler
    int    user_id;      // 4 bytes at offset 4
    char   grade;        // 1 byte at offset 8
                         // 7 bytes of PADDING inserted here
    double score;        // 8 bytes at offset 16
} StudentUnoptimised;    // Total: 24 bytes

// GOOD layout: reordered largest-to-smallest — padding mostly eliminated
typedef struct {
    double score;        // 8 bytes at offset 0
    int    user_id;      // 4 bytes at offset 8
    char   is_active;    // 1 byte at offset 12
    char   grade;        // 1 byte at offset 13
                         // 2 bytes of padding at end to round up to multiple of 8
} StudentOptimised;      // Total: 16 bytes

int main(void) {
    printf("=== Unoptimised Layout ===\n");
    printf("sizeof = %zu bytes\n",         sizeof(StudentUnoptimised));
    printf("is_active offset : %zu\n",     offsetof(StudentUnoptimised, is_active));
    printf("user_id   offset : %zu\n",     offsetof(StudentUnoptimised, user_id));
    printf("grade     offset : %zu\n",     offsetof(StudentUnoptimised, grade));
    printf("score     offset : %zu\n",     offsetof(StudentUnoptimised, score));

    printf("\n=== Optimised Layout (reordered) ===\n");
    printf("sizeof = %zu bytes\n",         sizeof(StudentOptimised));
    printf("score     offset : %zu\n",     offsetof(StudentOptimised, score));
    printf("user_id   offset : %zu\n",     offsetof(StudentOptimised, user_id));
    printf("is_active offset : %zu\n",     offsetof(StudentOptimised, is_active));
    printf("grade     offset : %zu\n",     offsetof(StudentOptimised, grade));

    printf("\nMemory saved per instance: %zu bytes\n",
           sizeof(StudentUnoptimised) - sizeof(StudentOptimised));
    // With 1 million students in memory, that's 8 MB saved

    return 0;
}

#include <stdio.h>
#include <stdint.h>  // for uint8_t, uint32_t

// A union that lets us treat a 4-byte IPv4 address as either
// a single 32-bit integer OR four individual octets.
// This is a textbook legitimate use of a union.
typedef union {
    uint32_t as_integer;    // View the address as one 32-bit number
    uint8_t  octets[4];     // View the same bytes as four separate octets
} IPv4Address;

// A tagged union — the 'type' field tells us which union member is valid.
// This is the safe pattern for using unions in application code.
typedef enum {
    SENSOR_TEMPERATURE,
    SENSOR_PRESSURE,
    SENSOR_HUMIDITY
} SensorType;

typedef struct {
    SensorType type;         // The TAG — always check this before reading the union
    union {
        float   temperature_celsius;  // Valid when type == SENSOR_TEMPERATURE
        float   pressure_hpa;         // Valid when type == SENSOR_PRESSURE
        uint8_t humidity_percent;     // Valid when type == SENSOR_HUMIDITY
    } reading;               // All three share the same 4 bytes
} SensorReading;

void print_sensor_reading(const SensorReading *s) {
    switch (s->type) {
        case SENSOR_TEMPERATURE:
            printf("Temperature : %.2f C\n", s->reading.temperature_celsius);
            break;
        case SENSOR_PRESSURE:
            printf("Pressure    : %.2f hPa\n", s->reading.pressure_hpa);
            break;
        case SENSOR_HUMIDITY:
            printf("Humidity    : %u %%\n", s->reading.humidity_percent);
            break;
    }
}

int main(void) {
    // --- IPv4 union demo ---
    IPv4Address addr;
    addr.as_integer = 0xC0A80101;  // 192.168.1.1 in hex (big-endian representation)

    printf("=== IPv4 Union Demo ===\n");
    printf("As integer : 0x%08X\n", addr.as_integer);
    // NOTE: octet order depends on host endianness (little-endian shown here)
    printf("As octets  : %u.%u.%u.%u\n",
           addr.octets[3], addr.octets[2],
           addr.octets[1], addr.octets[0]);

    printf("sizeof(IPv4Address) = %zu bytes\n", sizeof(IPv4Address));

    // --- Tagged union demo ---
    printf("\n=== Sensor Tagged Union Demo ===\n");

    SensorReading temp_reading = {
        .type = SENSOR_TEMPERATURE,
        .reading.temperature_celsius = 23.7f
    };

    SensorReading pressure_reading = {
        .type = SENSOR_PRESSURE,
        .reading.pressure_hpa = 1013.25f
    };

    SensorReading humidity_reading = {
        .type = SENSOR_HUMIDITY,
        .reading.humidity_percent = 68
    };

    print_sensor_reading(&temp_reading);
    print_sensor_reading(&pressure_reading);
    print_sensor_reading(&humidity_reading);

    // Show that all three sensor readings share the same memory footprint
    printf("\nsizeof(SensorReading) = %zu bytes\n", sizeof(SensorReading));

    return 0;
}

#include <stdio.h>
#include <stdlib.h>

// Every node in our expression tree is one of these types
typedef enum {
    NODE_NUMBER,     // A literal integer value like 42
    NODE_VARIABLE,   // A named variable like 'x'
    NODE_BINARY_OP   // An operation like left + right
} NodeType;

typedef enum {
    OP_ADD,
    OP_SUBTRACT,
    OP_MULTIPLY
} BinaryOperator;

// Forward declaration so we can have self-referential pointers
typedef struct ExprNode ExprNode;

struct ExprNode {
    NodeType type;   // The tag — ALWAYS set this, ALWAYS check it before reading

    union {
        // Used when type == NODE_NUMBER
        int literal_value;

        // Used when type == NODE_VARIABLE
        char variable_name[16];

        // Used when type == NODE_BINARY_OP
        struct {
            BinaryOperator  op;
            ExprNode       *left;   // Pointer — nodes can't contain themselves directly
            ExprNode       *right;
        } binary;
    } data;
};

// Helper constructors — clean API hides the union details from callers
ExprNode *make_number(int value) {
    ExprNode *node = malloc(sizeof(ExprNode));
    node->type = NODE_NUMBER;
    node->data.literal_value = value;
    return node;
}

ExprNode *make_binary(BinaryOperator op, ExprNode *left, ExprNode *right) {
    ExprNode *node = malloc(sizeof(ExprNode));
    node->type = NODE_BINARY_OP;
    node->data.binary.op    = op;
    node->data.binary.left  = left;
    node->data.binary.right = right;
    return node;
}

// Recursive evaluator — the type tag drives every decision
int evaluate(const ExprNode *node) {
    switch (node->type) {
        case NODE_NUMBER:
            return node->data.literal_value;

        case NODE_BINARY_OP: {
            int left_val  = evaluate(node->data.binary.left);
            int right_val = evaluate(node->data.binary.right);
            switch (node->data.binary.op) {
                case OP_ADD:      return left_val + right_val;
                case OP_SUBTRACT: return left_val - right_val;
                case OP_MULTIPLY: return left_val * right_val;
            }
        }

        case NODE_VARIABLE:
            // Variable lookup not implemented in this demo
            return 0;
    }
    return 0;  // Unreachable — silences compiler warning
}

void free_tree(ExprNode *node) {
    if (node == NULL) return;
    if (node->type == NODE_BINARY_OP) {
        free_tree(node->data.binary.left);
        free_tree(node->data.binary.right);
    }
    free(node);
}

int main(void) {
    // Build the expression tree for: (3 + 4) * (10 - 2)
    //
    //         MULTIPLY
    //        /        \
    //      ADD       SUBTRACT
    //     /   \      /      \
    //    3     4   10        2

    ExprNode *left_branch  = make_binary(OP_ADD,      make_number(3),  make_number(4));
    ExprNode *right_branch = make_binary(OP_SUBTRACT, make_number(10), make_number(2));
    ExprNode *root         = make_binary(OP_MULTIPLY, left_branch, right_branch);

    int result = evaluate(root);
    printf("(3 + 4) * (10 - 2) = %d\n", result);

    // Show that each node is the same size regardless of which union member is active
    printf("sizeof(ExprNode)    = %zu bytes\n", sizeof(ExprNode));

    free_tree(root);  // Clean up — always free what you malloc
    return 0;
}