Two foundational C topics, built up layer by layer - the mental models, how they sit in memory, the dynamic-allocation rules interviewers love, and the patterns (and bugs) that come up again and again.

Part 1 · Pointers

1.1 - What is a pointer?

Every variable lives somewhere in memory. Memory is a long street of numbered houses - each house is a byte, and its number is an address. A pointer is just a variable that stores an address.

int x = 42;     // x lives at some address, say 0x100, and holds 42
int *p = &x;    // p holds the value 0x100 (the address of x)

Three operators to internalize:

Operator	Name	Meaning
`&`	Address-of	Give me the address of this variable
`*` (in a declaration)	Pointer type	This variable holds an address
`*` (on a pointer)	Dereference	Go to the address and read the value there

#include <stdio.h>

int main() {
    int x = 42;
    int *p = &x;

    printf("Value of x:     %d\n", x);    // 42
    printf("Address of x:   %p\n", &x);   // 0x...
    printf("Value of p:     %p\n", p);    // same address
    printf("Dereferenced p: %d\n", *p);   // 42

    *p = 100;   // change x through the pointer
    printf("x is now:       %d\n", x);    // 100
}

Mental model: p is a signpost. &x writes an address on the signpost. *p says "follow the signpost and look at what is there."

1.2 - Why do pointers exist?

Pass by reference - modify a caller variable inside a function.
Dynamic memory - allocate at runtime.
Efficiency - pass large data without copying it.
Data structures - linked lists, trees, graphs.
Low-level control - hardware, OS kernels, embedded systems.

1.3 - Pointer types & sizes

A pointer’s type tells the compiler how many bytes to read when dereferencing. The pointer itself is always the same size (8 bytes on a 64-bit system).

char   *cp;   // dereference reads 1 byte
int    *ip;   // dereference reads 4 bytes
double *dp;   // dereference reads 8 bytes

Exercises - Level 1 (Beginner)

Write swap(int *a, int *b) that swaps two integers. Test it in main.
Write increment(int *n) that adds 1 to a number. Print before and after.
Declare an int, a pointer to it, and a pointer to that pointer (double pointer). Print the value using **.

Show solutions

// 1
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 2
void increment(int *n) { (*n)++; }

// 3
int x = 5;
int *p = &x;
int **pp = &p;
printf("%d\n", **pp);  // 5

1.4 - Pointers and arrays

In C, the array name decays to a pointer to its first element.

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;          // same as &arr[0]

printf("%d\n", arr[2]);     // 30
printf("%d\n", *(p + 2));   // 30  -- pointer arithmetic
printf("%d\n", p[2]);       // 30  -- same thing

Pointer arithmetic moves by the size of the type: p + 1 on an int* moves 4 bytes; on a double* it moves 8.

// Iterating an array with a pointer
for (int *p = arr; p < arr + 5; p++) {
    printf("%d ", *p);
}

1.5 - Pointers and functions

// Value is copied -- original unchanged
void fail(int x) { x = 99; }

// Pointer -- we modify the original
void succeed(int *x) { *x = 99; }

// Returning a pointer to the caller's variable -- OK
int* safe(int *x) { (*x)++; return x; }

// DANGER -- never do this:
int* dangerous() {
    int local = 5;
    return &local;   // local is destroyed when the function returns!
}

1.6 - Dynamic memory: malloc, calloc, realloc, free

The stack is automatic but limited. The heap lets you allocate at runtime.

#include <stdlib.h>

// malloc -- raw bytes, uninitialized
int *p = malloc(sizeof(int));
*p = 42;
free(p);

// calloc -- allocates and zeroes
int *arr = calloc(10, sizeof(int));   // 10 ints, all zero
free(arr);

// realloc -- resize an allocation
int *buf = malloc(5 * sizeof(int));
buf = realloc(buf, 10 * sizeof(int)); // grow to 10 ints
free(buf);

The golden rules:

Always check whether malloc returned NULL.
Every malloc has exactly one free.
Never use memory after free (use-after-free).
Never free the same pointer twice (double-free).
Never return a pointer to a stack variable.

int *safe_alloc(int n) {
    int *p = malloc(n * sizeof(int));
    if (p == NULL) {
        fprintf(stderr, "Allocation failed!\n");
        exit(1);
    }
    return p;
}

Exercises - Level 2 (Intermediate)

int* create_array(int n) - allocate an array of n ints, fill with 1..n, return it. Print and free in main.
reverse(int *arr, int n) - reverse in place using pointer arithmetic (no []).
char* my_strdup(const char *s) - allocate, copy the string, return it.

Show solutions

// 1
int* create_array(int n) {
    int *arr = malloc(n * sizeof(int));
    if (!arr) exit(1);
    for (int i = 0; i < n; i++) arr[i] = i + 1;
    return arr;
}

// 2
void reverse(int *arr, int n) {
    int *left = arr, *right = arr + n - 1;
    while (left < right) {
        int temp = *left;
        *left++ = *right;
        *right-- = temp;
    }
}

// 3
char* my_strdup(const char *s) {
    int len = 0;
    while (s[len]) len++;
    char *copy = malloc(len + 1);
    if (!copy) exit(1);
    for (int i = 0; i <= len; i++) copy[i] = s[i];
    return copy;
}

1.7 - Function pointers

Functions live in memory too. You can point to them, store them, and pass them.

// Syntax: returntype (*name)(param_types)
int add(int a, int b) { return a + b; }
int mul(int a, int b) { return a * b; }

int main() {
    int (*op)(int, int);   // pointer to a function (2 ints -> int)
    op = add; printf("%d\n", op(3, 4));  // 7
    op = mul; printf("%d\n", op(3, 4));  // 12
}

The practical use is callbacks - this is exactly how qsort works:

void apply(int *arr, int n, int (*fn)(int)) {
    for (int i = 0; i < n; i++)
        arr[i] = fn(arr[i]);
}

int square(int x) { return x * x; }
int negate(int x) { return -x; }
// apply(arr, 5, square);

1.8 - The void* pointer

void* can hold any address but can’t be dereferenced without casting. It’s how C writes generic code.

void print_bytes(void *ptr, int n) {
    unsigned char *p = (unsigned char *)ptr;
    for (int i = 0; i < n; i++)
        printf("%02X ", p[i]);
    printf("\n");
}

int x = 0xDEADBEEF;
print_bytes(&x, sizeof(x));

Part 2 · Structs

2.1 - What is a struct?

A struct groups related variables under one name - a custom type.

struct Point {
    int x;
    int y;
};

int main() {
    struct Point p;             // declare
    p.x = 10;                  // dot operator
    p.y = 20;
    struct Point q = {5, 15};  // initialize
    printf("(%d, %d)\n", p.x, p.y);
}

typedef avoids writing struct every time:

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

Point p = {10, 20};   // cleaner

2.2 - Structs in memory (padding)

Members are laid out in order, but the compiler inserts padding for alignment.

typedef struct {
    char   a;   // 1 byte
    // 3 bytes padding
    int    b;   // 4 bytes
    char   c;   // 1 byte
    // 7 bytes padding
    double d;   // 8 bytes
} Padded;       // likely 24 bytes, not 14

printf("%zu\n", sizeof(Padded));  // probably 24

Order members largest-to-smallest to minimize padding.

2.3 - Pointers to structs (the arrow operator)

Point p = {10, 20};
Point *ptr = &p;

printf("%d\n", (*ptr).x);  // dereference then dot
printf("%d\n", ptr->x);    // arrow operator (preferred)

ptr->x = 99;               // modify through the pointer

2.4 - Passing structs to functions

typedef struct { float x, y, z; } Vec3;

// BAD for large structs -- copies the whole thing
float length_copy(Vec3 v) {
    return sqrt(v.x*v.x + v.y*v.y + v.z*v.z);
}

// BETTER -- pass by pointer (no copy)
float length_ptr(const Vec3 *v) {
    return sqrt(v->x*v->x + v->y*v->y + v->z*v->z);
}

// Returning a small struct is fine
Vec3 add(const Vec3 *a, const Vec3 *b) {
    return (Vec3){a->x + b->x, a->y + b->y, a->z + b->z};
}

Use const Vec3 * when you won’t modify - it documents intent and prevents bugs.

Exercises - Level 3 (Intermediate-Advanced)

Rectangle with width/height; write area and perimeter taking const Rectangle *.
Student with name[50], grade, id; return a pointer to the highest-grade student in an array.
Allocate 5 Students, fill them, sort by grade with qsort + a comparator, print them.

Show solutions

// 1
typedef struct { float width, height; } Rectangle;
float area(const Rectangle *r)      { return r->width * r->height; }
float perimeter(const Rectangle *r) { return 2 * (r->width + r->height); }

// 2
typedef struct { char name[50]; float grade; int id; } Student;
Student* top_student(Student *arr, int n) {
    Student *top = &arr[0];
    for (int i = 1; i < n; i++)
        if (arr[i].grade > top->grade) top = &arr[i];
    return top;
}

// 3
int cmp_grade(const void *a, const void *b) {
    const Student *sa = a, *sb = b;
    return (sa->grade < sb->grade) - (sa->grade > sb->grade); // descending
}
// qsort(students, 5, sizeof(Student), cmp_grade);

Part 3 · Combining structs & pointers

3.1 - Linked lists

The classic structure that needs both - a self-referential struct.

typedef struct Node {
    int data;
    struct Node *next;   // pointer to the same type
} Node;

Node* new_node(int val) {
    Node *n = malloc(sizeof(Node));
    n->data = val;
    n->next = NULL;
    return n;
}

Node* prepend(Node *head, int val) {
    Node *n = new_node(val);
    n->next = head;
    return n;
}

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

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

3.2 - Pointer-to-pointer for list modification

Using Node** lets a function modify the head pointer itself - and removes the special case for deleting the first node.

void append(Node **head, int val) {
    Node *n = new_node(val);
    if (!*head) { *head = n; return; }
    Node *curr = *head;
    while (curr->next) curr = curr->next;
    curr->next = n;
}

void delete_val(Node **head, int val) {
    Node **curr = head;
    while (*curr) {
        if ((*curr)->data == val) {
            Node *tmp = *curr;
            *curr = (*curr)->next;
            free(tmp);
            return;
        }
        curr = &(*curr)->next;
    }
}

3.3 - Nested & complex structures

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

typedef struct {
    char    name[50];
    int     age;
    Address addr;        // embedded struct
    Address *work_addr;  // pointer to struct
} Person;

Person p = {
    .name = "Alice",
    .age  = 30,
    .addr = {"123 Main St", "Springfield", 12345}
};

printf("%s\n", p.addr.city);
printf("%s\n", p.work_addr->city);  // if allocated

3.4 - Opaque pointers & encapsulation

Hide implementation details, like C++ private members:

// stack.h
typedef struct Stack Stack;   // incomplete type -- internals hidden
Stack* stack_create();
void   stack_push(Stack *s, int val);
int    stack_pop(Stack *s);
void   stack_destroy(Stack *s);

// stack.c -- full definition only here
struct Stack { int *data; int top; int capacity; };

Stack* stack_create() {
    Stack *s = malloc(sizeof(Stack));
    s->data = malloc(16 * sizeof(int));
    s->top = 0; s->capacity = 16;
    return s;
}

void stack_push(Stack *s, int val) {
    if (s->top == s->capacity) {
        s->capacity *= 2;
        s->data = realloc(s->data, s->capacity * sizeof(int));
    }
    s->data[s->top++] = val;
}

Exercises - Level 4 (Advanced)

Doubly linked list with data, prev, next - append, prepend, delete, print_forward/backward.
Generic dynamic array using void*: vec_init, vec_push, vec_get, vec_free.
Binary search tree with insert, search, and inorder traversal.

3.5 - Common pointer bugs

Bug	Description	Detection
Null dereference	`*p` when `p == NULL`	Always check the malloc return
Dangling pointer	Accessing freed memory	Set `p = NULL` after free
Buffer overflow	Writing past array bounds	valgrind, AddressSanitizer
Memory leak	`malloc` without `free`	valgrind --leak-check=full
Double free	`free(p)` twice	Set `p = NULL` after free
Stack overflow	Too-deep recursion	Watch recursion depth

Compile with maximum safety:

gcc -Wall -Wextra -fsanitize=address,undefined -g program.c

Part 4 · Expert

4.1 - Casting, aliasing & type punning

// Inspect the bytes of any value
float f = 3.14f;
unsigned char *bytes = (unsigned char*)&f;
for (int i = 0; i < sizeof(f); i++)
    printf("%02X ", bytes[i]);

// Safe type punning via a union (avoid strict-aliasing UB)
typedef union { float f; uint32_t u; } FloatBits;
FloatBits fb = { .f = 3.14f };
printf("%08X\n", fb.u);   // raw bits of the float

4.2 - Multidimensional & pointer arrays

// 2D array -- contiguous in memory
int matrix[3][4];
int (*row_ptr)[4] = matrix;   // pointer to an array of 4 ints

// Array of pointers -- rows can have different lengths (jagged)
int *rows[3];
rows[0] = malloc(2 * sizeof(int));
rows[1] = malloc(5 * sizeof(int));
rows[2] = malloc(3 * sizeof(int));

4.3 - Const correctness

int x = 5;
const int *p = &x;        // can't change *p, can change p
int * const q = &x;       // can change *q, can't change q
const int * const r = &x; // can change neither
// Read right-to-left: "r is a const pointer to const int"