← C

Structures, Unions & Enums

Linked Lists

← Structures, Unions & Enums

Select a question from the sidebar

15 questions in this topic

Question 1 / 15

How do you declare and initialize structs in C, including C99 designated initializers?

Structs in C group related variables under one name. There are several ways to declare and initialize them:

Declaration:

struct Point { int x; int y; };

Initialization methods:

Positional initialization:

struct Point p = {10, 20};

Fields are assigned in declaration order.

C99 designated initializers:

struct Point p = {.x = 10, .y = 20};

Fields are named explicitly -- order does not matter, unspecified fields are zero-initialized.

Partial initialization:

struct Point p = {10}; /* x=10, y=0 */

Unspecified fields are zero-initialized.

Zero initialization:

struct Point p = {0}; /* all fields zero */

Compound literal (C99):

struct Point p = (struct Point){.x = 5, .y = 10};

Designated initializers are a C99 feature and are especially useful for:

Structs with many fields (only initialize what you need)
Self-documenting code (field names visible at initialization)
Forward-compatible code (adding new fields does not break existing initializers)

Pseudo Code

Positional: struct S s = {val1, val2, val3};
  Fields assigned in order; unspecified = 0

Designated (C99): struct S s = {.field2 = val2, .field1 = val1};
  Order doesn't matter; unspecified = 0

Zero init: struct S s = {0};
  All fields zero-initialized

Compound literal: func((struct S){.x = 1, .y = 2});

Code

#include <stdio.h>

struct Point {
    int x;
    int y;
};

struct Config {
    int width;
    int height;
    int fullscreen;
    int vsync;
    int fps_limit;
};

void print_point(struct Point p) {
    printf("(%d, %d)\n", p.x, p.y);
}

int main(void) {
    /* Positional initialization */
    struct Point p1 = {10, 20};
    print_point(p1); /* (10, 20) */

    /* C99 designated initializers */
    struct Point p2 = {.y = 50, .x = 30}; /* order doesn't matter */
    print_point(p2); /* (30, 50) */

    /* Partial initialization: unspecified fields = 0 */
    struct Point p3 = {.x = 7};
    print_point(p3); /* (7, 0) */

    /* Zero initialization */
    struct Point p4 = {0};
    print_point(p4); /* (0, 0) */

    /* Designated initializers shine with large structs */
    struct Config cfg = {
        .width = 1920,
        .height = 1080,
        .fullscreen = 1,
        /* vsync and fps_limit default to 0 */
    };
    printf("Config: %dx%d fullscreen=%d vsync=%d\n",
           cfg.width, cfg.height, cfg.fullscreen, cfg.vsync);

    /* Compound literal (C99) -- useful for passing to functions */
    print_point((struct Point){.x = 100, .y = 200}); /* (100, 200) */

    return 0;
}

(10, 20)
(30, 50)
(7, 0)
(0, 0)
Config: 1920x1080 fullscreen=1 vsync=0
(100, 200)

Key Points

•Positional init assigns fields in declaration order
•C99 designated initializers use .field = value syntax -- order does not matter
•Unspecified fields are always zero-initialized in both styles
•{0} zero-initializes the entire struct
•Compound literals create temporary struct values inline

Gotchas

•Designated initializers are C99 -- not available in strict C89 mode
•In C (unlike C++), designated initializer order can differ from declaration order
•Positional init breaks silently if fields are reordered in the struct definition
•struct S s; without = {0} leaves fields uninitialized (garbage) -- unlike global structs which are zero-initialized

Declare: struct Point { int x; int y; };. Initialize positionally {10, 20} or with C99 designated initializers {.x = 10, .y = 20}. Unspecified fields default to 0. Use {0} for full zero-init.

•Designated initializers: .field = value, order-independent, unset = 0
•{0} zero-initializes the entire struct

#include <stdio.h>

struct Point { int x; int y; };

int main(void) {
    struct Point p1 = {10, 20};            /* positional */
    struct Point p2 = {.y = 5, .x = 3};   /* designated (C99) */
    struct Point p3 = {0};                 /* all zeros */
    printf("(%d,%d) (%d,%d) (%d,%d)\n",
           p1.x, p1.y, p2.x, p2.y, p3.x, p3.y);
    /* (10,20) (3,5) (0,0) */
    return 0;
}

(10,20) (3,5) (0,0)

Local struct variables without initializer contain garbage -- always initialize

Question 2 / 15

How do nested structures work in C?

Nested structures are structs that contain other structs as members. This is C's mechanism for composition (building complex types from simpler ones).

Access: Use the dot operator chained: outer.inner.field. With pointers: ptr->inner.field or (*ptr).inner.field.

Initialization: Can use nested braces or C99 designated initializers for clarity.

Common patterns:

Geographic data: struct Location { struct GPS coords; struct Address addr; };
UI elements: struct Button { struct Rect bounds; struct Color color; };
Database records: struct Employee { struct Name name; struct Department dept; };

Nested structs are stored contiguously in memory (with possible padding for alignment). This means accessing nested fields is efficient -- no pointer dereferencing, just offset calculation.

Pseudo Code

struct Inner { int a; int b; };
struct Outer {
    struct Inner inner;  /* embedded, not a pointer */
    int c;
};

Access: outer.inner.a
Init:   struct Outer o = {{1, 2}, 3};
Init:   struct Outer o = {.inner = {.a = 1, .b = 2}, .c = 3};
Ptr:    ptr->inner.a

Code

#include <stdio.h>

struct Address {
    char street[50];
    char city[30];
    int zip;
};

struct Person {
    char name[50];
    int age;
    struct Address addr; /* nested struct */
};

void print_person(const struct Person *p) {
    printf("%s (age %d)\n", p->name, p->age);
    printf("  %s, %s %d\n", p->addr.street, p->addr.city, p->addr.zip);
}

int main(void) {
    /* Positional initialization with nested braces */
    struct Person p1 = {
        "Alice", 30,
        {"123 Main St", "Springfield", 62701}
    };
    print_person(&p1);

    /* C99 designated initializers (much clearer) */
    struct Person p2 = {
        .name = "Bob",
        .age = 25,
        .addr = {
            .street = "456 Oak Ave",
            .city = "Portland",
            .zip = 97201
        }
    };
    print_person(&p2);

    /* Modify nested field */
    p2.addr.zip = 97202;
    printf("Updated zip: %d\n", p2.addr.zip);

    return 0;
}

Alice (age 30)
  123 Main St, Springfield 62701
Bob (age 25)
  456 Oak Ave, Portland 97201
Updated zip: 97202

Key Points

•Nested structs are embedded by value, not by pointer -- stored contiguously
•Access with chained dot: outer.inner.field; with pointer: ptr->inner.field
•C99 designated initializers make nested initialization much more readable
•Nested struct assignment copies all fields (shallow copy by value)
•No limit on nesting depth, but deep nesting hurts readability

Gotchas

•Nested struct copy is shallow: if inner struct has pointers, only the pointer is copied, not the pointed-to data
•Adding fields to an inner struct changes the outer struct's size and layout
•Padding between nested struct members can waste memory
•Cannot forward-reference: inner struct must be defined before the outer struct

A struct can contain other structs as members. Access with chained dot: outer.inner.field. With pointers: ptr->inner.field. Nested structs are stored contiguously (by value, not by pointer).

•Nested structs are embedded by value, accessed with chained dot operator
•Designated initializers make nested init readable

#include <stdio.h>

struct Point { int x, y; };
struct Rect { struct Point origin; int w, h; };

int main(void) {
    struct Rect r = {.origin = {.x = 10, .y = 20}, .w = 100, .h = 50};
    printf("origin=(%d,%d) size=%dx%d\n",
           r.origin.x, r.origin.y, r.w, r.h);
    return 0;
}

origin=(10,20) size=100x50

Shallow copy: nested pointer members are not deep-copied

Question 3 / 15

How do you use struct pointers and the arrow operator?

When you have a pointer to a struct, you access members using the arrow operator (->) instead of the dot operator.

Equivalence: ptr->member is syntactic sugar for (*ptr).member. The parentheses in (*ptr).member are necessary because . binds tighter than *.

Why use pointers to structs:

Efficiency: Passing large structs by pointer avoids copying
Modification: Functions can modify the caller's struct
Dynamic allocation: malloc returns a pointer
Linked data structures: Nodes contain pointers to other nodes

The arrow operator chains: For nested struct pointers, chain arrows: list->head->next->data.

Pseudo Code

struct S { int x; };
struct S s = {42};
struct S *p = &s;

Dot operator (on struct):    s.x
Arrow operator (on pointer): p->x
Equivalent:                  (*p).x

Why -> exists:
  (*p).x is cumbersome and error-prone
  p->x is cleaner and chains well: p->inner->field

Code

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

struct Student {
    char name[50];
    int grade;
};

/* Pass by pointer: efficient, can modify */
void promote(struct Student *s) {
    s->grade += 1; /* arrow operator */
}

/* Pass by const pointer: efficient, read-only */
void print_student(const struct Student *s) {
    printf("%s: grade %d\n", s->name, s->grade);
}

int main(void) {
    /* Stack-allocated struct with pointer */
    struct Student alice = {"Alice", 10};
    struct Student *p = &alice;

    printf("%s grade: %d\n", p->name, p->grade); /* Alice grade: 10 */
    printf("Same: %d\n", (*p).grade);             /* 10 -- equivalent */

    promote(p);
    print_student(p); /* Alice: grade 11 */

    /* Heap-allocated struct */
    struct Student *bob = malloc(sizeof(*bob));
    if (bob) {
        strcpy(bob->name, "Bob");
        bob->grade = 8;
        print_student(bob); /* Bob: grade 8 */
        free(bob);
    }

    return 0;
}

Alice grade: 10
Same: 10
Alice: grade 11
Bob: grade 8

Key Points

•ptr->member is equivalent to (*ptr).member
•Arrow operator is necessary because . binds tighter than *
•Pass structs by pointer for efficiency (avoids copying) and mutability
•Use const pointer (const struct S *p) for read-only access
•Heap-allocated structs are always accessed through pointers

Gotchas

•*p.member is wrong: it parses as *(p.member) -- use (*p).member or p->member
•Dereferencing a NULL struct pointer is undefined behavior (common crash source)
•Arrow operator only works on pointers, not on struct values
•Returning a pointer to a local struct is a dangling pointer bug

ptr->member accesses a struct member through a pointer. Equivalent to (*ptr).member. Use for efficiency (avoid copying), mutability, and heap-allocated structs.

•ptr->member is syntactic sugar for (*ptr).member
•Pass structs by pointer for efficiency and mutability

#include <stdio.h>

struct Point { int x, y; };

void move(struct Point *p, int dx, int dy) {
    p->x += dx;
    p->y += dy;
}

int main(void) {
    struct Point pt = {10, 20};
    move(&pt, 5, -3);
    printf("(%d, %d)\n", pt.x, pt.y); /* (15, 17) */
    return 0;
}

(15, 17)

*p.member parses as *(p.member), not (*p).member -- always use -> with pointers

Question 4 / 15

What are self-referential structures and how are they used for linked lists?

A self-referential structure is a struct that contains a pointer to its own type. This is the foundation of dynamic data structures: linked lists, trees, graphs.

Why a pointer, not an embedded struct: A struct cannot contain an instance of itself (infinite recursion in size calculation), but it can contain a pointer to itself because all pointers have a fixed size.

Key syntax note: You must use the struct tag (not typedef) inside the definition because the typedef is not yet complete:

struct Node {
    int data;
    struct Node *next; /* OK: pointer to same struct type */
};

Common self-referential patterns:

Singly linked list: struct Node { int data; struct Node *next; };
Doubly linked list: struct Node { int data; struct Node *prev; struct Node *next; };
Binary tree: struct TreeNode { int data; struct TreeNode *left, *right; };

Pseudo Code

struct Node {
    data_type data;
    struct Node *next;  /* pointer to same type */
};

Linked list operations:
  Create: node = malloc(sizeof(struct Node))
  Link:   node->next = existing_node
  Traverse: while (current != NULL) current = current->next
  Delete: save = current->next; free(current); current = save

Code

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

/* Self-referential structure for singly linked list */
struct Node {
    int data;
    struct Node *next;
};

struct Node *create_node(int data) {
    struct Node *n = malloc(sizeof(*n));
    if (n) {
        n->data = data;
        n->next = NULL;
    }
    return n;
}

void push_front(struct Node **head, int data) {
    struct Node *new_node = create_node(data);
    if (new_node) {
        new_node->next = *head;
        *head = new_node;
    }
}

void print_list(const struct Node *head) {
    const struct Node *curr = head;
    while (curr) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("NULL\n");
}

void free_list(struct Node *head) {
    while (head) {
        struct Node *tmp = head;
        head = head->next;
        free(tmp);
    }
}

int main(void) {
    struct Node *list = NULL;
    push_front(&list, 30);
    push_front(&list, 20);
    push_front(&list, 10);

    print_list(list); /* 10 -> 20 -> 30 -> NULL */

    free_list(list);
    return 0;
}

10 -> 20 -> 30 -> NULL

Key Points

•A struct can contain a pointer to its own type (self-referential)
•Cannot contain an instance of itself -- only a pointer (fixed size)
•Foundation of linked lists, trees, and graphs
•Must use struct tag inside the definition: struct Node *next, not Node *next
•push_front requires double pointer (struct Node **) to modify the head

Gotchas

•Forgetting to set next to NULL in new nodes causes garbage pointer traversal
•Memory leaks if you lose the head pointer without freeing all nodes
•Cannot use typedef name inside the struct definition -- use the struct tag
•Circular references (cycles) require careful traversal to avoid infinite loops

A self-referential struct has a pointer to its own type: struct Node { int data; struct Node *next; };. This enables linked lists, trees, and graphs. Must use struct Node *, not an embedded struct Node.

•Pointer to own type enables linked data structures
•Must use struct tag inside the definition, not typedef alias

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

struct Node { int data; struct Node *next; };

int main(void) {
    struct Node *a = malloc(sizeof(*a));
    struct Node *b = malloc(sizeof(*b));
    a->data = 10; a->next = b;
    b->data = 20; b->next = NULL;

    struct Node *p = a;
    while (p) { printf("%d ", p->data); p = p->next; }
    /* 10 20 */
    printf("\n");
    free(a); free(b);
    return 0;
}

10 20

Always set next to NULL for terminal nodes to avoid garbage traversal

Question 5 / 15

What is structure padding and alignment, and why does sizeof(struct) differ from the sum of field sizes?

Structure padding is extra bytes inserted by the compiler between struct members to align each member to its natural alignment boundary. This is needed because most CPUs access memory more efficiently (or require) data to be aligned to addresses that are multiples of the data size.

Alignment rules (typical):

char: 1-byte aligned (any address)
short: 2-byte aligned
int, float: 4-byte aligned
double, long long, pointers (64-bit): 8-byte aligned

The struct's overall alignment is the alignment of its most strictly-aligned member. The struct's total size is padded to be a multiple of this alignment (trailing padding).

Example:

struct Bad {  char a; double b; char c; };
// Layout: a(1) + pad(7) + b(8) + c(1) + pad(7) = 24 bytes

struct Good { double b; char a; char c; };
// Layout: b(8) + a(1) + c(1) + pad(6) = 16 bytes

Optimizing struct size: Order fields from largest alignment to smallest to minimize padding.

Pseudo Code

Alignment rule:
  Each member aligned to multiple of its own size (or max alignment)
  Struct total size = multiple of largest member alignment

struct Example { char a; int b; char c; };
  Offset 0: a (1 byte)
  Offset 1-3: PADDING (3 bytes) -- align b to 4
  Offset 4-7: b (4 bytes)
  Offset 8: c (1 byte)
  Offset 9-11: PADDING (3 bytes) -- struct size multiple of 4
  Total: 12 bytes (not 6!)

Optimized: struct Example { int b; char a; char c; };
  Offset 0-3: b (4 bytes)
  Offset 4: a (1 byte)
  Offset 5: c (1 byte)
  Offset 6-7: PADDING (2 bytes)
  Total: 8 bytes

Code

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

struct Padded {
    char a;    /* 1 byte */
    /* 3 bytes padding */
    int b;     /* 4 bytes */
    char c;    /* 1 byte */
    /* 3 bytes padding */
};
/* Total: 12 bytes */

struct Optimized {
    int b;     /* 4 bytes */
    char a;    /* 1 byte */
    char c;    /* 1 byte */
    /* 2 bytes padding */
};
/* Total: 8 bytes */

struct WithDouble {
    char a;     /* 1 byte */
    /* 7 bytes padding */
    double b;   /* 8 bytes */
    char c;     /* 1 byte */
    /* 7 bytes padding */
};
/* Total: 24 bytes */

int main(void) {
    printf("struct Padded:    %zu bytes\n", sizeof(struct Padded));    /* 12 */
    printf("struct Optimized: %zu bytes\n", sizeof(struct Optimized)); /* 8 */
    printf("struct WithDouble:%zu bytes\n", sizeof(struct WithDouble));/* 24 */

    /* Use offsetof to see exact field positions */
    printf("\nPadded layout:\n");
    printf("  a at offset %zu\n", offsetof(struct Padded, a)); /* 0 */
    printf("  b at offset %zu\n", offsetof(struct Padded, b)); /* 4 */
    printf("  c at offset %zu\n", offsetof(struct Padded, c)); /* 8 */

    printf("\nOptimized layout:\n");
    printf("  b at offset %zu\n", offsetof(struct Optimized, b)); /* 0 */
    printf("  a at offset %zu\n", offsetof(struct Optimized, a)); /* 4 */
    printf("  c at offset %zu\n", offsetof(struct Optimized, c)); /* 5 */

    /* Sum of fields vs sizeof */
    printf("\nSum of Padded fields: %zu\n",
           sizeof(char) + sizeof(int) + sizeof(char)); /* 6 */
    printf("sizeof(struct Padded): %zu\n", sizeof(struct Padded)); /* 12 */

    return 0;
}

struct Padded:    12 bytes
struct Optimized: 8 bytes
struct WithDouble:24 bytes

Padded layout:
  a at offset 0
  b at offset 4
  c at offset 8

Optimized layout:
  b at offset 0
  a at offset 4
  c at offset 5

Sum of Padded fields: 6
sizeof(struct Padded): 12

Key Points

•Compilers insert padding bytes to align each member to its natural boundary
•Struct total size is rounded up to a multiple of the largest member's alignment
•offsetof() macro reveals exact field positions within a struct
•Order fields largest-to-smallest to minimize padding
•sizeof(struct) includes all padding bytes

Gotchas

•sizeof(struct) is almost never equal to the sum of sizeof(each member)
•Reordering fields changes sizeof -- this matters for binary protocols and file formats
•Different compilers or architectures may use different alignment/padding rules
•Comparing structs with memcmp can give wrong results because padding bytes are indeterminate

Compilers add padding bytes to align struct members to their natural boundaries. sizeof(struct) includes padding and is usually larger than the sum of member sizes. Order fields largest-to-smallest to minimize waste.

•Padding aligns members; total size rounded to largest alignment
•Order fields largest-to-smallest to minimize padding

#include <stdio.h>
#include <stddef.h>

struct Bad  { char a; int b; char c; }; /* 12 bytes */
struct Good { int b; char a; char c; }; /* 8 bytes */

int main(void) {
    printf("Bad: %zu, Good: %zu\n",
           sizeof(struct Bad), sizeof(struct Good)); /* 12, 8 */
    printf("b at offset %zu\n", offsetof(struct Bad, b)); /* 4 */
    return 0;
}

Bad: 12, Good: 8
b at offset 4

memcmp on structs can fail because padding bytes contain garbage

Question 6 / 15

How do you pack structures to remove padding using #pragma pack or attribute((packed))?

Packing removes padding from structs, making sizeof equal to the sum of member sizes. This is needed for binary file formats, network protocols, and hardware register mappings where exact byte layout matters.

Method 1: #pragma pack (portable across MSVC, GCC, Clang)

#pragma pack(push, 1)  /* save current packing, set to 1-byte alignment */
struct Header { ... };
#pragma pack(pop)       /* restore previous packing */

Method 2: __attribute__((packed)) (GCC/Clang only)

struct Header {
    char type;
    int length;
} __attribute__((packed));

Performance impact:

Packed structs may cause misaligned access, which is:
- Slower on x86 (hardware handles it, but with a penalty)
- A hardware fault (bus error) on ARM, SPARC, and some embedded architectures
Taking the address of a packed member and passing it to a function expecting aligned data is undefined behavior

Pseudo Code

Without packing:
  struct S { char a; int b; };  /* 8 bytes (3 padding) */

With packing:
  #pragma pack(push, 1)
  struct S { char a; int b; };  /* 5 bytes (no padding) */
  #pragma pack(pop)

Or:
  struct S { char a; int b; } __attribute__((packed)); /* 5 bytes */

Code

#include <stdio.h>
#include <stdint.h>

/* Normal struct with padding */
struct Normal {
    char type;     /* 1 byte */
    /* 3 bytes padding */
    int length;    /* 4 bytes */
    char flags;    /* 1 byte */
    /* 3 bytes padding */
};
/* Total: 12 bytes */

/* Packed struct -- no padding */
#pragma pack(push, 1)
struct PacketHeader {
    uint8_t type;     /* 1 byte */
    uint32_t length;  /* 4 bytes */
    uint8_t flags;    /* 1 byte */
};
#pragma pack(pop)
/* Total: 6 bytes */

/* Alternative GCC/Clang syntax */
struct __attribute__((packed)) GCCPacked {
    uint8_t type;
    uint32_t length;
    uint8_t flags;
};
/* Total: 6 bytes */

int main(void) {
    printf("Normal size:       %zu\n", sizeof(struct Normal));       /* 12 */
    printf("PacketHeader size: %zu\n", sizeof(struct PacketHeader)); /* 6 */
    printf("GCCPacked size:    %zu\n", sizeof(struct GCCPacked));    /* 6 */

    /* Use packed struct for binary protocol */
    struct PacketHeader pkt = {.type = 0x01, .length = 1024, .flags = 0x80};
    printf("Packet: type=0x%02x length=%u flags=0x%02x\n",
           pkt.type, pkt.length, pkt.flags);

    /* Accessing packed members is safe through the struct itself */
    /* But taking address of misaligned member is dangerous: */
    /* uint32_t *p = &pkt.length; */  /* WARNING: misaligned pointer! */

    return 0;
}

Normal size:       12
PacketHeader size: 6
GCCPacked size:    6
Packet: type=0x01 length=1024 flags=0x80

Key Points

•#pragma pack(push, 1) ... #pragma pack(pop) removes all padding
•__attribute__((packed)) is GCC/Clang-specific alternative
•Use packed structs for binary protocols, file formats, hardware registers
•Always restore packing with #pragma pack(pop) to avoid affecting other structs
•Packed struct sizeof equals the exact sum of member sizes

Gotchas

•Misaligned access from packed structs is a hardware fault on ARM/SPARC (not just slow)
•Taking the address of a packed member creates a misaligned pointer -- UB when dereferenced as the aligned type
•Packed structs should not be used for general-purpose data -- only for I/O boundaries
•-Waddress-of-packed-member (GCC 9+) warns about misaligned pointer creation

#pragma pack(push, 1) or __attribute__((packed)) removes struct padding. Used for binary protocols and hardware registers. Causes misaligned access -- slow on x86, crashes on ARM.

•#pragma pack(push,1) removes padding; #pragma pack(pop) restores
•Only use for binary I/O, not general data

#include <stdio.h>
#include <stdint.h>

#pragma pack(push, 1)
struct Header {
    uint8_t type;
    uint32_t length;
};
#pragma pack(pop)

int main(void) {
    printf("%zu\n", sizeof(struct Header)); /* 5 (no padding) */
    return 0;
}

Misaligned access crashes on ARM/SPARC; never take address of packed member

Question 7 / 15

What are unions in C and what are their practical use cases?

A union is like a struct where all members share the same memory location. The union's size equals the size of its largest member. Only one member can hold a valid value at a time.

Key difference from struct:

Struct: members are laid out sequentially (total size = sum + padding)
Union: members overlap (total size = largest member + padding)

Practical use cases:

Type punning: Reinterpret the bits of one type as another (reading float bits as int). This is well-defined in C99 but technically UB in C++.
Variant/tagged union: Store different types in the same space, with a tag field indicating which type is active (discriminated union).
Memory efficiency: When you know only one of several fields will be used at a time.
Hardware register access: Map different bitfield views onto the same register.
Network protocol parsing: Overlay different header formats on the same buffer.

Pseudo Code

union Data {
    int i;      /* 4 bytes */
    float f;    /* 4 bytes */
    char c;     /* 1 byte */
};
sizeof(union Data) == 4  /* size of largest member */

Writing to one member and reading from another:
  union Data d;
  d.i = 42;     /* i is active */
  d.f = 3.14;   /* now f is active, i is invalid */
  /* d.i is now undefined (type punning exception aside) */

Code

#include <stdio.h>
#include <stdint.h>

/* Basic union */
union Number {
    int i;
    float f;
    char bytes[4];
};

/* Type punning: view float bits as integer */
void show_float_bits(float f) {
    union { float f; uint32_t i; } u;
    u.f = f;
    printf("float %.2f = bits 0x%08X\n", f, u.i);
}

/* Practical: network byte order conversion helper */
union IPv4 {
    uint32_t addr;
    uint8_t octets[4];
};

int main(void) {
    /* Union basics */
    union Number n;
    printf("sizeof(union Number) = %zu\n", sizeof(n)); /* 4 */

    n.i = 42;
    printf("As int: %d\n", n.i);     /* 42 */

    n.f = 3.14f;
    printf("As float: %.2f\n", n.f); /* 3.14 */
    /* n.i is now invalid (overwritten by f) */

    /* Type punning (well-defined in C99) */
    show_float_bits(3.14f);   /* float 3.14 = bits 0x4048F5C3 */
    show_float_bits(0.0f);    /* float 0.00 = bits 0x00000000 */
    show_float_bits(-1.0f);   /* float -1.00 = bits 0xBF800000 */

    /* IP address manipulation */
    union IPv4 ip;
    ip.octets[0] = 192;
    ip.octets[1] = 168;
    ip.octets[2] = 1;
    ip.octets[3] = 100;
    printf("IP: %u.%u.%u.%u (raw: 0x%08X)\n",
           ip.octets[0], ip.octets[1], ip.octets[2], ip.octets[3],
           ip.addr);

    return 0;
}

sizeof(union Number) = 4
As int: 42
As float: 3.14
float 3.14 = bits 0x4048F5C3
float 0.00 = bits 0x00000000
float -1.00 = bits 0xBF800000
IP: 192.168.1.100 (raw: 0x6401A8C0)
(IP raw value is platform-dependent due to byte order; shown for little-endian)

Key Points

•All union members share the same memory; size = largest member
•Only one member is valid at a time -- writing to one invalidates others
•Type punning through unions is well-defined in C99 (but UB in C++)
•Used for variant types, hardware registers, and memory efficiency
•sizeof(union) equals sizeof(largest member) plus any trailing padding

Gotchas

•Reading an inactive union member is UB in C89 and C++ -- but allowed in C99 for type punning
•Unions do not track which member is active -- programmer must manage this
•Union assignment copies the entire size of the union, not just the active member
•Padding rules still apply: union size may be larger than the largest member due to alignment

A union shares memory among all members -- only one is valid at a time. Size equals largest member. Use for type punning (C99), variant types, IP address manipulation, and memory-mapped registers.

•All members share same memory; size = largest member
•Type punning via union is well-defined in C99

#include <stdio.h>
#include <stdint.h>

union FloatBits {
    float f;
    uint32_t bits;
};

int main(void) {
    union FloatBits u;
    u.f = 3.14f;
    printf("%.2f as hex: 0x%08X\n", u.f, u.bits);
    printf("sizeof: %zu\n", sizeof(u)); /* 4 */
    return 0;
}

3.14 as hex: 0x4048F5C3
sizeof: 4

No tracking of active member -- programmer must manage this explicitly

Question 8 / 15

How do enums work in C and what is their underlying type?

An enum (enumeration) defines a set of named integer constants. It improves readability over raw #define constants.

Declaration and values:

enum Color { RED, GREEN, BLUE };
// RED=0, GREEN=1, BLUE=2 (auto-incremented from 0)

enum Status { OK = 200, NOT_FOUND = 404, ERROR = 500 };
// Explicit values

Underlying type:

In C, enum constants are always int (guaranteed by the standard)
The enum variable type is implementation-defined but compatible with int
The compiler may use a smaller type for the variable (char, short) if all values fit, but constants remain int
In C23, you can specify the underlying type: enum Color : unsigned char { ... }

Key properties:

Enum values are just integers -- no type safety (unlike C++ enum class)
Can be used in switch statements, array indexing, arithmetic
Duplicate values are allowed
Cannot iterate over enum values (no reflection)

Pseudo Code

enum Direction { NORTH, EAST, SOUTH, WEST };
  NORTH=0, EAST=1, SOUTH=2, WEST=3

enum Flags { A=1, B=2, C=4, D=8 };
  Can be used as bit flags

Enum constants are always int:
  printf("%zu\n", sizeof(NORTH)); /* sizeof(int) */

Enum variable may be smaller:
  enum Direction d;
  sizeof(d) may be < sizeof(int) on some compilers

Code

#include <stdio.h>

enum Direction { NORTH, EAST, SOUTH, WEST, NUM_DIRECTIONS };

enum HttpStatus {
    HTTP_OK = 200,
    HTTP_NOT_FOUND = 404,
    HTTP_INTERNAL_ERROR = 500
};

/* Enum as bit flags */
enum Permissions {
    PERM_READ = 1,    /* 001 */
    PERM_WRITE = 2,   /* 010 */
    PERM_EXEC = 4     /* 100 */
};

const char *direction_name(enum Direction d) {
    static const char *names[] = {"North", "East", "South", "West"};
    if (d >= 0 && d < NUM_DIRECTIONS) return names[d];
    return "Unknown";
}

int main(void) {
    /* Basic enum usage */
    enum Direction d = EAST;
    printf("%s (value=%d)\n", direction_name(d), d); /* East (value=1) */

    /* Enum in switch */
    enum HttpStatus status = HTTP_OK;
    switch (status) {
        case HTTP_OK:             printf("200 OK\n"); break;
        case HTTP_NOT_FOUND:      printf("404 Not Found\n"); break;
        case HTTP_INTERNAL_ERROR: printf("500 Error\n"); break;
    }

    /* Enum as bit flags */
    int perms = PERM_READ | PERM_WRITE;
    if (perms & PERM_READ)  printf("Can read\n");
    if (perms & PERM_WRITE) printf("Can write\n");
    if (perms & PERM_EXEC)  printf("Can execute\n");

    /* Enum constants are int */
    printf("sizeof(NORTH) = %zu\n", sizeof(NORTH));     /* sizeof(int) */
    printf("sizeof(enum Direction) = %zu\n", sizeof(enum Direction));

    /* NUM_DIRECTIONS trick for array sizing */
    const char *labels[NUM_DIRECTIONS] = {"N", "E", "S", "W"};
    for (int i = 0; i < NUM_DIRECTIONS; i++)
        printf("%s ", labels[i]);
    printf("\n");

    return 0;
}

East (value=1)
200 OK
Can read
Can write
sizeof(NORTH) = 4
sizeof(enum Direction) = 4
N E S W

Key Points

•Enum constants auto-increment from 0 unless explicitly set
•Enum constants are always type int in C
•No type safety: can assign any int to an enum variable without warning
•NUM_ELEMENTS sentinel pattern provides count for arrays and loops
•Enums can be used as bit flags with powers-of-two values

Gotchas

•No type safety: enum Direction d = 999; compiles without error in C
•Cannot iterate over enum values -- no reflection in C
•Enum variable size may differ from int -- do not assume sizeof(enum) == sizeof(int)
•Negative enum values are allowed: enum Sign { NEG = -1, ZERO = 0, POS = 1 };

Enums define named integer constants. Auto-increment from 0 unless specified. Constants are always int in C. No type safety -- any int can be assigned. Use NUM_X sentinel for array sizing.

•Auto-increment from 0; constants are int type
•No type safety in C; use NUM_X sentinel pattern

#include <stdio.h>

enum Color { RED, GREEN, BLUE, NUM_COLORS };

int main(void) {
    enum Color c = GREEN;
    printf("GREEN=%d, NUM_COLORS=%d\n", c, NUM_COLORS); /* 1, 3 */
    const char *names[NUM_COLORS] = {"Red", "Green", "Blue"};
    printf("%s\n", names[c]); /* Green */
    return 0;
}

GREEN=1, NUM_COLORS=3
Green

Any integer can be assigned to enum variable -- no compiler error

Question 9 / 15

What are bit fields in C and what are their use cases and pitfalls?

Bit fields allow you to specify the exact number of bits a struct member occupies. They pack multiple small values into fewer bytes.

Syntax:

struct Flags {
    unsigned int read  : 1;  /* 1 bit */
    unsigned int write : 1;  /* 1 bit */
    unsigned int exec  : 1;  /* 1 bit */
};

Use cases:

Hardware registers: Map to exact bit positions in a register
Compact flags: Store many boolean flags in minimal space
Protocol headers: Match bit-level specifications (though packing issues apply)
Memory-constrained embedded systems: Save RAM

Rules:

Bit field types: unsigned int, signed int, _Bool (C99), implementation-defined for other types
Width 0 (int : 0;) forces alignment to next storage unit boundary
Unnamed bit fields (padding): int : 3; adds 3 bits of padding
Cannot take the address of a bit field (&flags.read is illegal)
Cannot create an array of bit fields

Portability concerns:

Bit order (MSB first vs LSB first) is implementation-defined
Packing across storage unit boundaries is implementation-defined
Not suitable for cross-platform binary formats

Pseudo Code

struct Flags {
    unsigned int a : 1;  /* 1 bit: 0 or 1 */
    unsigned int b : 3;  /* 3 bits: 0 to 7 */
    unsigned int c : 4;  /* 4 bits: 0 to 15 */
};
/* All 8 bits may fit in a single byte (implementation-dependent) */

Access like normal members: flags.a = 1; flags.b = 5;
Cannot: &flags.a (no address of bit fields)
Cannot: sizeof(flags.a) (no sizeof bit fields)

Code

#include <stdio.h>

/* Compact flags using bit fields */
struct Permissions {
    unsigned int read  : 1;
    unsigned int write : 1;
    unsigned int exec  : 1;
};

/* Bit field for compact data storage */
struct Date {
    unsigned int year  : 12; /* 0-4095 */
    unsigned int month : 4;  /* 0-15 */
    unsigned int day   : 5;  /* 0-31 */
};

/* Hardware register example */
struct StatusRegister {
    unsigned int busy      : 1;
    unsigned int error     : 1;
    unsigned int mode      : 3;
    unsigned int reserved  : 3;
};

int main(void) {
    /* Permissions */
    struct Permissions p = {.read = 1, .write = 1, .exec = 0};
    printf("sizeof(Permissions) = %zu\n", sizeof(p)); /* typically 4 */
    printf("read=%u write=%u exec=%u\n", p.read, p.write, p.exec);

    /* Compact date */
    struct Date d = {.year = 2024, .month = 12, .day = 25};
    printf("sizeof(Date) = %zu\n", sizeof(d)); /* typically 4 */
    printf("Date: %u-%02u-%02u\n", d.year, d.month, d.day);

    /* Overflow: value exceeds bit width */
    struct Date d2 = {.year = 2024, .month = 15, .day = 32};
    printf("Overflow day (32 in 5 bits): %u\n", d2.day); /* 0 (wraps) */

    /* Cannot take address of bit field */
    /* int *ptr = &p.read; */  /* ERROR: cannot take address */

    return 0;
}

sizeof(Permissions) = 4
read=1 write=1 exec=0
sizeof(Date) = 4
Date: 2024-12-25
Overflow day (32 in 5 bits): 0

Key Points

•Bit fields specify exact bit widths for struct members
•Use unsigned int for bit fields to avoid sign-extension surprises
•Cannot take the address of a bit field (&bf is illegal)
•Bit order and packing are implementation-defined -- not portable
•Width 0 (int : 0;) forces alignment to next storage unit

Gotchas

•Signed bit fields with width 1 can only be 0 or -1 (not 0 or 1) -- always use unsigned
•Bit field layout is implementation-defined: not suitable for portable binary formats
•Assigning a value larger than the bit width silently truncates (no warning in some compilers)
•Cannot use sizeof or & on individual bit fields

Bit fields let you specify exact bit widths in a struct: unsigned int flag : 1;. Used for compact flags, hardware registers, and memory-constrained systems. Layout is implementation-defined -- not portable across platforms.

•Specify bit widths with : N after member name
•Always use unsigned; layout is implementation-defined

#include <stdio.h>

struct Flags {
    unsigned int read  : 1;
    unsigned int write : 1;
    unsigned int exec  : 1;
};

int main(void) {
    struct Flags f = {.read = 1, .write = 0, .exec = 1};
    printf("r=%u w=%u x=%u, size=%zu\n",
           f.read, f.write, f.exec, sizeof(f));
    return 0;
}

r=1 w=0 x=1, size=4

Signed 1-bit field holds 0 or -1, not 0 or 1 -- use unsigned

Question 10 / 15

How does struct assignment work in C (shallow copy)?

In C, structs can be assigned with =, which performs a shallow (member-wise) copy. This copies every byte of the struct, including padding.

What gets copied:

All primitive members (int, float, char, etc.) -- values are duplicated
Arrays inside the struct -- entire array is copied
Pointers -- the pointer value is copied (both structs point to the same data)
Nested structs -- recursively copied by value

What does NOT happen:

No deep copy of pointed-to data
Both original and copy share the same dynamically allocated memory
Modifying one pointer's target affects both structs
Double-free risk if both structs try to free the same pointer

Equivalent to memcpy:

struct S a = b; /* same as memcpy(&a, &b, sizeof(a)); */

When you need deep copy: Write a custom clone/copy function that allocates new memory for pointer members.

Pseudo Code

struct S { int x; char *name; };

struct S a = {42, malloc(10)};
struct S b = a;  /* shallow copy */

Result:
  b.x == 42           (independent copy)
  b.name == a.name    (SAME pointer! shared memory)

Dangers:
  free(a.name);
  printf("%s", b.name);  /* dangling pointer! */

Deep copy:
  b.name = malloc(strlen(a.name) + 1);
  strcpy(b.name, a.name);  /* independent copy */

Code

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

struct Person {
    char name[50];  /* array: copied by value */
    int age;        /* primitive: copied by value */
    char *email;    /* pointer: only address copied (shallow!) */
};

/* Deep copy function */
struct Person person_clone(const struct Person *src) {
    struct Person copy = *src; /* start with shallow copy */
    if (src->email) {
        copy.email = malloc(strlen(src->email) + 1);
        if (copy.email) {
            strcpy(copy.email, src->email);
        }
    }
    return copy;
}

void person_free(struct Person *p) {
    free(p->email);
    p->email = NULL;
}

int main(void) {
    struct Person alice = {
        .name = "Alice",
        .age = 30,
        .email = malloc(20)
    };
    strcpy(alice.email, "alice@example.com");

    /* Shallow copy: name array copied, but email pointer shared! */
    struct Person shallow = alice;
    printf("Shallow: %s, %s\n", shallow.name, shallow.email);
    printf("Same pointer? %s\n",
           (alice.email == shallow.email) ? "YES (danger!)" : "no");

    /* Deep copy: email has its own memory */
    struct Person deep = person_clone(&alice);
    printf("Deep: %s, %s\n", deep.name, deep.email);
    printf("Same pointer? %s\n",
           (alice.email == deep.email) ? "yes" : "NO (safe)");

    /* Clean up -- only free once for shared pointer! */
    person_free(&alice);
    /* shallow.email is now dangling! */
    person_free(&deep); /* safe: independent copy */

    return 0;
}

Shallow: Alice, alice@example.com
Same pointer? YES (danger!)
Deep: Alice, alice@example.com
Same pointer? NO (safe)

Key Points

•Struct assignment (=) performs a shallow/member-wise byte copy
•Primitive members and arrays are fully copied (independent)
•Pointer members: only the address is copied -- both structs share the same data
•Write a custom clone function for deep copies of pointer members
•Struct assignment also copies padding bytes

Gotchas

•Double-free: both original and copy own the same pointer -- only one should free it
•Modifying data through one copy's pointer affects the other copy
•Arrays in structs ARE fully copied (unlike standalone arrays which decay to pointers)
•No operator overloading in C -- cannot make = do a deep copy automatically

Struct = does a shallow byte copy. Primitives and embedded arrays are independent. Pointers are shared (same address). Write a custom clone function for deep copies. Watch for double-free with shared pointers.

•= copies bytes, sharing pointers; write clone() for deep copy
•Arrays in structs are fully copied, but pointers are shared

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

struct S { int x; char *p; };

int main(void) {
    struct S a = {42, malloc(10)};
    strcpy(a.p, "hello");

    struct S b = a; /* shallow copy */
    printf("Same pointer: %s\n",
           a.p == b.p ? "yes (shared!)" : "no");
    /* Only free ONCE -- a.p and b.p are the same */
    free(a.p);
    return 0;
}

Same pointer: yes (shared!)

Double-free risk when two structs share the same pointer after assignment

Question 11 / 15

What is the difference between passing structs by value versus by pointer to functions?

C functions can receive structs in two ways:

By value:

void func(struct S s) { ... }
func(my_struct);

A complete copy of the struct is made on the stack
Changes inside the function do not affect the original
Expensive for large structs (copying overhead)
Simple and safe (no aliasing concerns)

By pointer:

void func(struct S *s) { ... }
func(&my_struct);

Only a pointer (8 bytes on 64-bit) is passed
Changes via s->member modify the original
Efficient for any struct size
Use const struct S * for read-only access

Guidelines:

Small structs (1-2 members, <= 16 bytes): pass by value (fits in registers)
Large structs: always pass by pointer
Need to modify the original: pass by pointer
Need read-only access: pass by const pointer
Return values: small structs can be returned by value; large ones via output pointer

Pseudo Code

By value:
  void f(struct S s);
  f(my_s);              /* entire struct copied */
  s.x = 10;            /* does NOT affect my_s */

By pointer:
  void f(struct S *s);
  f(&my_s);             /* only pointer copied (8 bytes) */
  s->x = 10;           /* DOES affect my_s */

Read-only pointer:
  void f(const struct S *s);
  f(&my_s);             /* efficient, cannot modify */

Code

#include <stdio.h>

struct Matrix {
    double data[100]; /* 800 bytes -- expensive to copy */
};

struct Point {
    int x, y; /* 8 bytes -- cheap to copy */
};

/* Pass small struct by value -- simple and safe */
struct Point offset_point(struct Point p, int dx, int dy) {
    p.x += dx; /* modifies local copy only */
    p.y += dy;
    return p;  /* return by value is fine for small structs */
}

/* Pass large struct by const pointer -- efficient, read-only */
double matrix_trace(const struct Matrix *m) {
    double sum = 0;
    for (int i = 0; i < 10; i++) {
        sum += m->data[i * 10 + i]; /* diagonal elements */
    }
    return sum;
}

/* Pass by pointer -- can modify the original */
void matrix_zero(struct Matrix *m) {
    for (int i = 0; i < 100; i++) {
        m->data[i] = 0.0;
    }
}

int main(void) {
    /* Small struct: pass by value */
    struct Point p = {10, 20};
    struct Point p2 = offset_point(p, 5, -3);
    printf("original: (%d,%d)\n", p.x, p.y);   /* (10,20) unchanged */
    printf("offset:   (%d,%d)\n", p2.x, p2.y); /* (15,17) */

    /* Large struct: pass by pointer */
    struct Matrix m;
    matrix_zero(&m);
    m.data[0] = 1.0; m.data[11] = 2.0; m.data[22] = 3.0;
    printf("trace: %.1f\n", matrix_trace(&m)); /* 6.0 */

    return 0;
}

original: (10,20)
offset:   (15,17)
trace: 6.0

Key Points

•By value: copies entire struct, changes do not affect original, expensive for large structs
•By pointer: passes address only, changes affect original, always efficient
•Use const pointer for read-only access: const struct S *
•Small structs (<= 16 bytes) can be efficiently passed and returned by value
•Large structs should always be passed by pointer

Gotchas

•Passing a large struct by value copies it onto the stack -- can cause stack overflow
•Forgetting const on a read-only pointer parameter is a missed optimization and documentation opportunity
•Returning a pointer to a local struct is a dangling pointer bug -- return by value or use output parameter
•Some ABIs pass small structs in registers, making by-value actually faster than by-pointer

By value: copies the whole struct (safe, expensive for large structs). By pointer: passes address (efficient, can modify original). Use const struct S * for read-only. Small structs (<=16 bytes) are fine by value.

•Large structs: by pointer; small structs: by value is fine
•Use const pointer for read-only efficiency

#include <stdio.h>

struct Point { int x, y; };

void move(struct Point *p, int dx, int dy) { /* by pointer: modifies original */
    p->x += dx;
    p->y += dy;
}

struct Point shifted(struct Point p, int dx, int dy) { /* by value: copy */
    p.x += dx;
    p.y += dy;
    return p;
}

int main(void) {
    struct Point pt = {10, 20};
    move(&pt, 5, -3);
    printf("(%d,%d)\n", pt.x, pt.y); /* (15,17) -- modified */
    return 0;
}

(15,17)

Never return a pointer to a local struct -- it is a dangling pointer

Question 12 / 15

How does typedef work with structs in C?

typedef creates an alias (alternative name) for a type. With structs, it eliminates the need to write struct keyword every time.

Without typedef:

struct Point { int x; int y; };
struct Point p = {10, 20}; /* must say 'struct Point' */

With typedef:

typedef struct { int x; int y; } Point;
Point p = {10, 20}; /* just 'Point' */

Three common patterns:

Anonymous struct with typedef:

typedef struct { int x; int y; } Point;

Clean but cannot be forward-declared.

Named struct with typedef:

typedef struct Point { int x; int y; } Point;

Can use either struct Point or Point.

Forward declaration pattern:

typedef struct Point Point; /* forward declare */
struct Point { int x; int y; };

Required for opaque pointers and self-referential structs.

Style debate: Linux kernel style guide discourages typedef for structs (prefers explicit struct keyword). Many C projects prefer typedef for brevity.

Pseudo Code

Without typedef:
  struct Point p;         /* must use 'struct' keyword */
  void func(struct Point *p);

With typedef:
  Point p;               /* cleaner */
  void func(Point *p);

Self-referential with typedef:
  typedef struct Node {
      int data;
      struct Node *next;  /* must use 'struct Node' here */
  } Node;

Code

#include <stdio.h>

/* Pattern 1: Anonymous struct with typedef */
typedef struct {
    double x, y;
} Vec2;

/* Pattern 2: Named struct with typedef */
typedef struct Color {
    unsigned char r, g, b, a;
} Color;

/* Pattern 3: Self-referential struct */
typedef struct Node {
    int data;
    struct Node *next; /* must use 'struct Node', not 'Node' here */
} Node;

/* Pattern 4: Forward declaration for opaque pointer */
typedef struct Engine Engine; /* forward declaration */
/* struct Engine is defined in the .c file */

void print_vec(Vec2 v) {
    printf("(%.1f, %.1f)\n", v.x, v.y);
}

int main(void) {
    /* Using typedef -- no 'struct' keyword needed */
    Vec2 pos = {3.0, 4.0};
    print_vec(pos); /* (3.0, 4.0) */

    Color red = {255, 0, 0, 255};
    printf("Red: (%u, %u, %u)\n", red.r, red.g, red.b);

    /* Named struct can use either form */
    struct Color blue = {0, 0, 255, 255}; /* also valid */
    Color green = {0, 255, 0, 255};
    printf("Blue: (%u, %u, %u)\n", blue.r, blue.g, blue.b);
    printf("Green: (%u, %u, %u)\n", green.r, green.g, green.b);

    /* Self-referential */
    Node a = {10, NULL};
    Node b = {20, &a};
    printf("%d -> %d\n", b.data, b.next->data); /* 20 -> 10 */

    return 0;
}

(3.0, 4.0)
Red: (255, 0, 0)
Blue: (0, 0, 255)
Green: (0, 255, 0)
20 -> 10

Key Points

•typedef creates a type alias, eliminating the 'struct' keyword in usage
•Anonymous typedef structs cannot be forward-declared
•Named struct + typedef allows both struct Tag and Alias usage
•Self-referential structs must use struct Tag *next inside the definition
•Linux kernel style avoids typedef for structs; many C projects prefer it

Gotchas

•Inside a self-referential struct, you must write struct Node *next, not Node *next -- the typedef is not complete yet
•Anonymous typedef structs cannot use forward declarations (needed for opaque pointers)
•typedef hides whether a type is a struct, which some argue reduces readability
•In C++, struct names are already types without typedef -- but C requires it

typedef struct { ... } Name; creates a type alias so you can write Name instead of struct Name. For self-referential structs, use typedef struct Node { int data; struct Node *next; } Node;.

•typedef lets you omit 'struct' keyword in variable declarations
•Self-referential: use struct Tag inside, typedef alias outside

#include <stdio.h>

typedef struct Node {
    int data;
    struct Node *next; /* must use 'struct Node' inside */
} Node;

int main(void) {
    Node a = {10, NULL};
    Node b = {20, &a};
    printf("%d -> %d\n", b.data, b.next->data); /* 20 -> 10 */
    return 0;
}

20 -> 10

Cannot forward-declare anonymous typedef structs -- name the struct for opaque pointers

Question 13 / 15

What are anonymous structs and unions in C11?

Anonymous structs and unions (C11) are struct/union members without a name. Their members are accessed directly from the enclosing struct, as if they were direct members.

Without anonymous union:

struct S { union { int i; float f; } u; };
s.u.i = 42; /* must use 'u' prefix */

With anonymous union (C11):

struct S { union { int i; float f; }; };
s.i = 42; /* direct access, no prefix */

Rules:

Anonymous structs/unions must be inside another struct or union
They cannot have a tag name
Their members are promoted to the enclosing scope
Member names must not conflict with other members of the enclosing struct

Use cases:

Cleaner tagged unions (discriminated unions)
Accessing parts of a larger value (e.g., vector components)
Overlaying different views of the same data

Note: This was a GCC/MSVC extension before C11 standardized it.

Pseudo Code

Without anonymous union:
  struct S { union { int i; float f; } u; };
  s.u.i = 42;  /* need prefix 'u' */

With anonymous union (C11):
  struct S { union { int i; float f; }; };
  s.i = 42;    /* direct access */

Anonymous struct in union:
  union Vec3 {
    struct { float x, y, z; };  /* access as v.x, v.y, v.z */
    float data[3];               /* access as v.data[0..2] */
  };

Code

#include <stdio.h>

/* Tagged union with anonymous union -- clean access */
typedef struct {
    enum { TYPE_INT, TYPE_FLOAT, TYPE_STRING } type;
    union {
        int i;
        float f;
        const char *s;
    }; /* anonymous union: access i/f/s directly */
} Value;

void print_value(const Value *v) {
    switch (v->type) {
        case TYPE_INT:    printf("int: %d\n", v->i); break;
        case TYPE_FLOAT:  printf("float: %.2f\n", v->f); break;
        case TYPE_STRING: printf("string: %s\n", v->s); break;
    }
}

/* Vector with dual access patterns */
typedef union {
    struct { float x, y, z; }; /* anonymous struct */
    float data[3];              /* array access */
} Vec3;

int main(void) {
    /* Tagged union with anonymous union */
    Value v1 = {.type = TYPE_INT, .i = 42};
    Value v2 = {.type = TYPE_FLOAT, .f = 3.14f};
    Value v3 = {.type = TYPE_STRING, .s = "hello"};

    print_value(&v1); /* int: 42 */
    print_value(&v2); /* float: 3.14 */
    print_value(&v3); /* string: hello */

    /* No 'u.' prefix needed -- direct access */
    printf("Direct access: %d\n", v1.i); /* 42 */

    /* Vector with anonymous struct */
    Vec3 v = {.x = 1.0f, .y = 2.0f, .z = 3.0f};
    printf("Named: (%.0f, %.0f, %.0f)\n", v.x, v.y, v.z);
    printf("Array: (%.0f, %.0f, %.0f)\n", v.data[0], v.data[1], v.data[2]);

    /* Both access the same memory */
    v.data[1] = 99.0f;
    printf("y after data[1]=99: %.0f\n", v.y); /* 99 */

    return 0;
}

int: 42
float: 3.14
string: hello
Direct access: 42
Named: (1, 2, 3)
Array: (1, 2, 3)
y after data[1]=99: 99

Key Points

•Anonymous structs/unions promote their members to the enclosing scope
•No intermediate name needed: s.i instead of s.u.i
•C11 feature (was a GCC/MSVC extension before standardization)
•Perfect for tagged unions and dual-access patterns (named + array)
•Member names must not conflict with enclosing struct members

Gotchas

•Not available in strict C99 mode -- requires -std=c11 or compiler extension flag
•Anonymous struct/union members cannot have their own tag name
•Name collisions between anonymous and outer members cause compile errors
•Some older compilers may not support anonymous structs (only anonymous unions)

C11 anonymous structs/unions have no name -- their members are accessed directly from the enclosing struct. struct S { union { int i; float f; }; }; allows s.i instead of s.u.i.

•Members promoted to enclosing scope for direct access
•C11 feature; eliminates intermediate name prefix

#include <stdio.h>

typedef struct {
    int type;
    union { int i; float f; }; /* anonymous union */
} Value;

int main(void) {
    Value v = {.type = 0, .i = 42};
    printf("%d\n", v.i); /* 42 -- direct access, no prefix */
    return 0;
}

Requires -std=c11 or later; member names must not conflict with outer struct

Question 14 / 15

Why can't you compare structs with == in C, and how do you compare them?

C does not allow == or != on structs. This is a deliberate language design decision because:

Padding bytes: Structs may contain padding with indeterminate values. Two structs with identical member values can have different padding bytes, making byte-wise comparison unreliable.
Pointer members: Should == compare pointer addresses or the pointed-to data? There is no single correct answer.
No operator overloading: C cannot define custom == behavior per type.

How to compare structs:

Member-by-member comparison (recommended):

int equal = (a.x == b.x && a.y == b.y);

Safe, explicit, handles all cases correctly.

memcmp (dangerous):

int equal = (memcmp(&a, &b, sizeof(a)) == 0);

Only safe if there is NO padding and NO pointer members. Usually NOT recommended.

Custom comparison function:

int point_equal(const struct Point *a, const struct Point *b);

Best practice for complex structs.

Pseudo Code

Why == fails:
  struct S { char a; int b; };
  struct S x = {1, 2};
  struct S y = {1, 2};
  /* x == y;  COMPILE ERROR */
  /* memcmp(&x, &y, sizeof(x)) may fail due to padding */

Correct approach:
  int equal = (x.a == y.a && x.b == y.b);  /* member by member */

Custom function:
  int s_equal(const struct S *a, const struct S *b) {
      return a->a == b->a && a->b == b->b;
  }

Code

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

struct Point {
    int x;
    int y;
};

struct Person {
    char name[50];
    int age;
    char *email; /* pointer member */
};

/* Member-by-member comparison (correct) */
int point_equal(const struct Point *a, const struct Point *b) {
    return a->x == b->x && a->y == b->y;
}

/* For structs with strings and pointers */
int person_equal(const struct Person *a, const struct Person *b) {
    return strcmp(a->name, b->name) == 0
        && a->age == b->age
        && (a->email == b->email || /* both NULL or same ptr */
            (a->email && b->email && strcmp(a->email, b->email) == 0));
}

int main(void) {
    /* struct Point: no padding (same-sized members), memcmp OK here */
    struct Point p1 = {10, 20};
    struct Point p2 = {10, 20};
    struct Point p3 = {10, 30};

    /* This would NOT compile: */
    /* if (p1 == p2) printf("equal\n"); */

    /* Member-by-member (recommended) */
    printf("p1 == p2: %s\n", point_equal(&p1, &p2) ? "yes" : "no"); /* yes */
    printf("p1 == p3: %s\n", point_equal(&p1, &p3) ? "yes" : "no"); /* no */

    /* memcmp -- works here because struct Point has no padding */
    printf("memcmp p1==p2: %s\n",
           memcmp(&p1, &p2, sizeof(p1)) == 0 ? "yes" : "no"); /* yes */

    /* Danger: struct with padding */
    struct { char a; int b; } x, y;
    x.a = 1; x.b = 2;
    y.a = 1; y.b = 2;
    /* memcmp may fail because padding bytes differ! */
    printf("memcmp with padding: %s\n",
           memcmp(&x, &y, sizeof(x)) == 0 ? "equal" : "may differ");

    return 0;
}

p1 == p2: yes
p1 == p3: no
memcmp p1==p2: yes
memcmp with padding: may differ
(memcmp with padding is platform-dependent; padding bytes may differ)

Key Points

•C does not support == or != for structs -- compile error
•Padding bytes make memcmp unreliable for struct comparison
•Always use member-by-member comparison or a custom function
•memcmp is only safe when there is guaranteed no padding and no pointers
•For strings, use strcmp; for pointers, compare pointed-to data

Gotchas

•memcmp fails on structs with padding -- padding bytes are indeterminate
•memcmp compares pointer addresses, not pointed-to content
•Even memset(&s, 0, sizeof(s)) before initialization may not guarantee equal padding on all platforms
•Floating-point comparison via memcmp cannot handle NaN or -0.0 vs +0.0 correctly

C forbids == on structs. memcmp fails due to padding. Use member-by-member comparison or a custom equality function.

•No == for structs in C; use member-by-member comparison
•memcmp is unreliable due to padding

#include <stdio.h>

struct Point { int x, y; };

int point_eq(const struct Point *a, const struct Point *b) {
    return a->x == b->x && a->y == b->y;
}

int main(void) {
    struct Point p1 = {10, 20}, p2 = {10, 20};
    /* if (p1 == p2) -- COMPILE ERROR */
    printf("%s\n", point_eq(&p1, &p2) ? "equal" : "not equal"); /* equal */
    return 0;
}

equal

memcmp on structs with padding gives unpredictable results

Question 15 / 15

How do you implement a tagged union (discriminated union) in C?

A tagged union (discriminated union) combines a union with an enum tag that identifies which union member is currently active. This is C's equivalent of sum types / variant types found in other languages.

Pattern:

typedef struct {
    enum { TYPE_A, TYPE_B, TYPE_C } tag;
    union {
        TypeA a;
        TypeB b;
        TypeC c;
    };
} Variant;

The tag field tracks which union member is valid. All operations must check the tag before accessing union members.

Real-world uses:

JSON values (null, bool, number, string, array, object)
Abstract syntax tree (AST) nodes
Event systems (different event types with different data)
Configuration values (int, float, string settings)
Interpreter values (different runtime types)

Safety: The programmer must ensure the tag matches the active union member. Accessing the wrong member is undefined behavior (or at least a logic bug).

Pseudo Code

1. Define enum for possible types
2. Define union with one member per type
3. Combine in a struct: tag + union
4. Every access must switch on the tag

struct Value {
    enum { INT, FLOAT, STRING } type;  /* tag */
    union { int i; float f; char *s; }; /* data */
};

Construct: v.type = INT; v.i = 42;
Access:    if (v.type == INT) use(v.i);
           else if (v.type == STRING) use(v.s);

Code

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

/* JSON-like value using tagged union */
typedef enum {
    VAL_NULL,
    VAL_BOOL,
    VAL_INT,
    VAL_FLOAT,
    VAL_STRING
} ValueType;

typedef struct {
    ValueType type; /* discriminant / tag */
    union {
        int boolean;
        long integer;
        double floating;
        char *string;
    }; /* anonymous union (C11) */
} Value;

/* Constructor functions */
Value val_null(void) {
    return (Value){.type = VAL_NULL};
}

Value val_int(long v) {
    return (Value){.type = VAL_INT, .integer = v};
}

Value val_float(double v) {
    return (Value){.type = VAL_FLOAT, .floating = v};
}

Value val_string(const char *s) {
    Value v = {.type = VAL_STRING};
    v.string = malloc(strlen(s) + 1);
    if (v.string) strcpy(v.string, s);
    return v;
}

Value val_bool(int b) {
    return (Value){.type = VAL_BOOL, .boolean = b != 0};
}

/* Safe access: always check the tag */
void print_value(const Value *v) {
    switch (v->type) {
        case VAL_NULL:   printf("null"); break;
        case VAL_BOOL:   printf("%s", v->boolean ? "true" : "false"); break;
        case VAL_INT:    printf("%ld", v->integer); break;
        case VAL_FLOAT:  printf("%.2f", v->floating); break;
        case VAL_STRING: printf("\"%s\"", v->string); break;
    }
    printf("\n");
}

void free_value(Value *v) {
    if (v->type == VAL_STRING) {
        free(v->string);
        v->string = NULL;
    }
    v->type = VAL_NULL;
}

int main(void) {
    Value values[] = {
        val_null(),
        val_bool(1),
        val_int(42),
        val_float(3.14),
        val_string("hello")
    };
    int n = sizeof(values) / sizeof(values[0]);

    for (int i = 0; i < n; i++) {
        printf("[%d] ", i);
        print_value(&values[i]);
    }

    /* Cleanup: only strings need freeing */
    for (int i = 0; i < n; i++) {
        free_value(&values[i]);
    }

    /* sizeof: union uses space of largest member */
    printf("sizeof(Value) = %zu\n", sizeof(Value));

    return 0;
}

[0] null
[1] true
[2] 42
[3] 3.14
[4] "hello"
sizeof(Value) = 16
(sizeof(Value) is platform-dependent)

Key Points

•Tagged union = enum tag + union data in a struct
•Tag tracks which union member is active; always check before access
•Use constructor functions to ensure tag and data are consistent
•Only the active union member's resources need cleanup (e.g., free for strings)
•C's equivalent of Rust's enum, Haskell's data types, TypeScript's discriminated unions

Gotchas

•No compiler enforcement: accessing the wrong union member is a silent bug
•Memory management depends on the active type -- must check tag before free
•Adding a new type requires updating ALL switch statements -- easy to miss one
•sizeof(Value) includes space for the largest union member even when holding a smaller type

A tagged union pairs an enum (tag) with a union (data). The tag tracks which member is active. Always switch on the tag before accessing. This is C's way to handle variant/sum types.

•enum tag + union data = tagged union
•Always check tag before accessing union members

#include <stdio.h>

typedef struct {
    enum { T_INT, T_FLOAT, T_STR } type;
    union { int i; float f; const char *s; };
} Value;

void print(const Value *v) {
    switch (v->type) {
        case T_INT:   printf("%d\n", v->i); break;
        case T_FLOAT: printf("%.2f\n", v->f); break;
        case T_STR:   printf("%s\n", v->s); break;
    }
}

int main(void) {
    Value v1 = {.type = T_INT, .i = 42};
    Value v2 = {.type = T_STR, .s = "hello"};
    print(&v1); /* 42 */
    print(&v2); /* hello */
    return 0;
}

42
hello

No compiler check: accessing wrong member is a silent logic bug

Built by onllm.dev

Home GitHub Support awesomePrep

Structures, Unions & Enums

Linked Lists

How do you declare and initialize structs in C, including C99 designated initializers?

How do nested structures work in C?

How do you use struct pointers and the arrow operator?

What are self-referential structures and how are they used for linked lists?

What is structure padding and alignment, and why does sizeof(struct) differ from the sum of field sizes?

How do you pack structures to remove padding using #pragma pack or __attribute__((packed))?

What are unions in C and what are their practical use cases?

How do enums work in C and what is their underlying type?

What are bit fields in C and what are their use cases and pitfalls?

How does struct assignment work in C (shallow copy)?

What is the difference between passing structs by value versus by pointer to functions?

How does typedef work with structs in C?

What are anonymous structs and unions in C11?

Why can't you compare structs with == in C, and how do you compare them?

How do you implement a tagged union (discriminated union) in C?

Structures, Unions & Enums

How do you pack structures to remove padding using #pragma pack or attribute((packed))?