Advanced C Programming Course

Lesson 1 • C Syntax and Program Structure

Covers translation units, preprocessor directives, and the anatomy of a valid C program. Provides the structural foundation every later chapter depends on.

Lesson 2 • Control Flow Constructs

Teaches if-else, switch, loops, and jump statements with practical examples. Control flow mastery is required before tackling functions and data structures.

Lesson 3 • Primitive Data Types and Variables

Examines integer, floating-point, and character types with their sizes and ranges. Accurate type selection prevents overflow and portability bugs throughout the course.

Lesson 4 • Operators and Expressions

Covers arithmetic, relational, logical, and bitwise operators with precedence rules. Correct expression evaluation is prerequisite to writing any non-trivial algorithm.

Lesson 1 • Parameter Passing Strategies

Contrasts pass-by-value and pass-by-pointer, explaining when each strategy is appropriate. This distinction is foundational for pointer-heavy chapters that follow.

Lesson 2 • Recursive Functions

Develops recursive thinking through classic problems and analyses stack depth limits. Recursion patterns recur in tree and graph algorithms in later chapters.

Lesson 3 • Scope, Linkage, and Storage Duration

Explains block, file, and program scope alongside internal and external linkage. Understanding linkage is essential for multi-file projects introduced next.

Lesson 4 • Function Declaration and Definition

Covers prototypes, return types, and the call stack mechanics behind function invocation. Proper declarations prevent implicit-function bugs seen in legacy codebases.

Lesson 1 • Pointer Fundamentals

Introduces address-of and dereference operators, pointer types, and null pointers. These basics underpin every advanced pointer technique in the chapter.

Lesson 2 • Pointers to Pointers and Complex Declarations

Covers double pointers, pointer arrays, and reading complex C declarations using the right-left rule. These constructs appear in dynamic data structures and callbacks.

Lesson 3 • Pointer Arithmetic and Array Relationships

Demonstrates how pointer arithmetic maps to array indexing and memory layout. Mastery here prevents off-by-one and buffer overrun errors in later projects.

Lesson 4 • Function Pointers and Callbacks

Teaches declaring, assigning, and invoking function pointers to implement callbacks and dispatch tables. This pattern is central to generic algorithms and plugin architectures.

Lesson 1 • Heap Allocation Functions

Covers malloc, calloc, realloc, and free with their contracts and failure modes. Correct usage of these functions is the entry point to all dynamic data structures.

Lesson 2 • Memory Leak Detection and Profiling

Uses Valgrind, AddressSanitizer, and heap profilers to locate and fix leaks. Profiling skills are applied throughout all remaining project-based chapters.

Lesson 3 • Custom Allocator Design

Implements a slab allocator and a bump-pointer allocator to understand allocator internals. Custom allocators are used in the systems programming and performance chapters.

Lesson 4 • Ownership and Lifetime Patterns

Defines clear ownership models—single owner, borrowed references, and arena allocation. Explicit ownership prevents double-free and use-after-free defects.

Lesson 1 • Struct Padding, Packing, and Alignment

Analyses compiler-inserted padding and techniques to minimise struct size. Compact structs reduce cache pressure in performance-critical applications.

Lesson 2 • Opaque Types and Encapsulation

Implements opaque pointer patterns to hide struct internals across translation units. Encapsulation enables stable APIs despite internal implementation changes.

Lesson 3 • Unions and Tagged Unions

Explains union memory sharing and implements tagged unions for type-safe variant data. Tagged unions are the foundation of discriminated-union patterns in C.

Lesson 4 • Bit-Fields and Hardware Register Modeling

Uses bit-fields to map hardware registers and protocol headers to C structs. This technique is essential for embedded and systems programming projects.

Lesson 1 • Graphs and Traversal Algorithms

Represents graphs with adjacency lists and matrices, then implements BFS and DFS. Graph traversal is the basis for pathfinding and dependency resolution algorithms.

Lesson 2 • Binary Search Trees and Balancing

Implements BST insert, search, and delete, then extends to AVL rotation-based balancing. Balanced trees guarantee O(log n) operations for ordered data access.

Lesson 3 • Hash Tables and Collision Resolution

Designs hash tables with separate chaining and open addressing, analysing load factors. Hash tables provide O(1) average lookup used in symbol tables and caches.

Lesson 4 • Linked Lists and Variants

Builds singly, doubly, and circular linked lists with insert, delete, and traversal operations. Linked lists introduce pointer manipulation patterns reused in all later structures.

Lesson 1 • Process Creation and Management

Covers fork, exec, wait, and exit to create and manage child processes. Process management is prerequisite to understanding inter-process communication.

Lesson 2 • Socket Programming and Networking

Builds TCP and UDP client-server applications using the BSD socket API. Network programming integrates file I/O, process, and signal skills from earlier sections.

Lesson 3 • Inter-Process Communication

Implements pipes, FIFOs, shared memory, and message queues for process coordination. IPC mechanisms are combined with sockets in the networking section.

Lesson 4 • Signals and Asynchronous Events

Registers signal handlers with sigaction and manages async-signal-safe operations. Signal handling is required for robust daemon and server implementations.

Lesson 1 • SIMD Intrinsics and Vectorisation

Writes auto-vectorisable loops and hand-coded SIMD intrinsics for data-parallel workloads. SIMD delivers order-of-magnitude speedups for numerical and media processing.

Lesson 2 • Compiler Optimisation Flags and Hints

Explores -O2, -O3, LTO, and PGO flags alongside restrict and likely/unlikely hints. Compiler-guided optimisation complements manual tuning with minimal code changes.

Lesson 3 • Profiling and Bottleneck Identification

Uses gprof, perf, and flame graphs to locate CPU and memory hotspots. Profiling before optimising prevents wasted effort on non-critical code paths.

Lesson 4 • Lock-Free and Wait-Free Algorithms

Implements atomic operations and compare-and-swap to build lock-free queues and counters. Lock-free techniques eliminate contention bottlenecks in multi-threaded programmes.