Enums, Structs & Unions

#include <stdio.h>

/* Define Point using typedef — no need to write "struct Point" later */
typedef struct {
    int x;
    int y;
} Point;

/* Rectangle composed of two Points */
typedef struct {
    Point top_left;      /* nested struct — a struct inside a struct */
    Point bottom_right;
} Rectangle;

/* Function taking a pointer to a Point — uses arrow operator */
void print_point(const Point *p) {
    printf("(%d, %d)", p->x, p->y);
}

/* Compute area — no pointer needed, pass by value */
int rect_area(Rectangle r) {
    int width  = r.bottom_right.x - r.top_left.x;
    int height = r.bottom_right.y - r.top_left.y;
    return width * height;
}

int main(void) {
    /* Designated initializer — order doesn't matter */
    Point origin = {.x = 0, .y = 0};
    Point corner = {.x = 10, .y = 5};

    printf("Origin: ");   print_point(&origin);  printf("\n");
    printf("Corner: ");   print_point(&corner);  printf("\n");

    /* Nested struct initialization */
    Rectangle r = { {0, 0}, {10, 5} };
    printf("Area: %d\n", rect_area(r));

    /* Modifying via pointer */
    Point *ptr = &corner;
    ptr->x = 20;           /* same as corner.x = 20 */
    ptr->y = 15;           /* same as corner.y = 15 */
    printf("New corner: "); print_point(&corner); printf("\n");

    /* sizeof */
    printf("sizeof(Point):     %zu bytes\n", sizeof(Point));
    printf("sizeof(Rectangle): %zu bytes\n", sizeof(Rectangle));

    return 0;
}

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

/* Self-referential struct: next points to another Node */
typedef struct Node {
    int         value;
    struct Node *next;   /* must use tag name here — typedef not yet complete */
} Node;

/* Allocate a new node on the heap */
Node *make_node(int val) {
    Node *n = malloc(sizeof(Node));
    if (!n) { perror("malloc"); exit(1); }
    n->value = val;
    n->next  = NULL;
    return n;
}

/* Print the whole list */
void print_list(Node *head) {
    Node *curr = head;
    while (curr != NULL) {
        printf("%d", curr->value);
        if (curr->next) printf(" -> ");
        curr = curr->next;
    }
    printf("\n");
}

/* Free all nodes */
void free_list(Node *head) {
    while (head) {
        Node *tmp = head->next;
        free(head);
        head = tmp;
    }
}

int main(void) {
    /* Build list: 1 -> 2 -> 3 */
    Node *head = make_node(1);
    head->next = make_node(2);
    head->next->next = make_node(3);

    print_list(head);   /* 1 -> 2 -> 3 */
    free_list(head);
    return 0;
}

#include <stdio.h>

union Data {
    int   i;
    float f;
    char  bytes[4];   /* lets us inspect individual bytes */
};

int main(void) {
    union Data d;

    /* Write an int */
    d.i = 0x41424344;   /* ASCII 'A'=41, 'B'=42, 'C'=43, 'D'=44 */

    printf("d.i = 0x%08x (%d)\n", d.i, d.i);
    printf("d.bytes: %02x %02x %02x %02x\n",
           (unsigned char)d.bytes[0],
           (unsigned char)d.bytes[1],
           (unsigned char)d.bytes[2],
           (unsigned char)d.bytes[3]);
    /* bytes[0] is lowest address — on little-endian: 44 43 42 41 */

    /* Write a float — NOW i is garbage, only f is valid */
    d.f = 3.14f;
    printf("d.f = %f\n", d.f);

    /* Size demonstration */
    printf("\nsizeof(union Data)   = %zu\n", sizeof(union Data));
    printf("sizeof(int)          = %zu\n",  sizeof(int));
    printf("sizeof(float)        = %zu\n",  sizeof(float));
    printf("sizeof(char[4])      = %zu\n",  sizeof(char[4]));
    /* All are 4 — union size = largest member = 4 */

    union { int i; double d; char s[16]; } big;
    printf("\nsizeof(big union)    = %zu\n", sizeof(big));
    /* = 16, the largest member (char s[16]) */

    return 0;
}

#include <stdio.h>

enum day_name { SUN, MON, TUE, WED, THU, FRI, SAT, DAY_UNDEF };

enum month_name {
    JAN, FEB, MAR, APR, MAY, JUN,
    JUL, AUG, SEP, OCT, NOV, DEC,
    MONTH_UNDEF
};

struct date {
    enum day_name   day;
    int             day_num;
    enum month_name month;
    int             year;
};

/* Array of structs */
typedef struct {
    char  name[32];
    float gpa;
    int   year;
} Student;

void print_student(const Student *s) {
    printf("%-12s  GPA: %.2f  Year: %d\n", s->name, s->gpa, s->year);
}

int main(void) {
    /* enum usage */
    struct date big_day = { MON, 7, JAN, 1980 };
    printf("Day number: %d\n", big_day.day);    /* MON = 1 */
    printf("Month num:  %d\n", big_day.month);  /* JAN  = 0 */

    /* Can increment enums */
    enum day_name tomorrow = big_day.day + 1;   /* TUE = 2 */
    printf("Tomorrow:   %d\n", tomorrow);

    /* Array of structs */
    Student cohort[3] = {
        {"Alice",   3.9, 2},
        {"Bob",     3.5, 3},
        {"Charlie", 3.7, 1},
    };

    printf("\nStudent cohort:\n");
    for (int i = 0; i < 3; i++) {
        print_student(&cohort[i]);   /* pass pointer to each element */
    }

    printf("\nsizeof(Student) = %zu bytes\n", sizeof(Student));
    printf("sizeof(cohort)  = %zu bytes (%zu elements)\n",
           sizeof(cohort), sizeof(cohort) / sizeof(cohort[0]));

    return 0;
}