C Programming Language Course

Lesson 1 • Setting Up the Development Environment

Installs and configures a compiler, editor, and build tools on major operating systems. Ensures every student can compile and run code before advancing.

Lesson 2 • History and Role of C

Covers C's origins, design philosophy, and why it remains dominant in systems software. Provides context for every design decision studied throughout the course.

Lesson 3 • Writing and Running Hello World

Applies environment knowledge to write, compile, and execute a complete first program. Confirms the toolchain works and introduces printf and return conventions.

Lesson 4 • Compilation and Execution Pipeline

Traces source code through preprocessing, compilation, assembly, and linking to a binary. Students understand what each stage produces and how errors are reported.

Lesson 1 • Variable Declaration and Initialization

Covers naming rules, storage classes, scope, and the importance of initialising variables. Prevents common bugs caused by uninitialised memory from the start.

Lesson 2 • Arithmetic and Assignment Operators

Explains the full set of arithmetic operators, compound assignment, and increment/decrement. Students evaluate complex expressions and predict their results accurately.

Lesson 3 • Type Conversion and Casting

Distinguishes implicit promotion from explicit casting and explains when each occurs. Students avoid data-loss bugs by understanding how C converts between types.

Lesson 4 • Fundamental Data Types

Introduces int, char, float, double, and void with their sizes and value ranges. Grounds students in the type system before any expression work begins.

Lesson 1 • Conditional Statements

Teaches if, else if, and else constructs with proper condition writing and nesting. Students translate real-world decision logic into correct C branching code.

Lesson 2 • Jump Statements and Loop Control

Covers break, continue, and goto with their effects on control flow and best practices. Students use break and continue effectively whilst avoiding goto misuse.

Lesson 3 • Loop Constructs: for and while

Introduces for and while loops with initialisation, condition, and update components. Students implement counting, accumulation, and search algorithms.

Lesson 4 • The do-while Loop

Explains the do-while loop's guaranteed first execution and its appropriate use cases. Students apply it to input validation and menu-driven programs.

Lesson 1 • Function Pointers

Teaches declaring, assigning, and invoking function pointers for callbacks and dispatch tables. Students use function pointers to write flexible, extensible C code.

Lesson 2 • Scope and Lifetime of Variables

Explains local, global, and static variable scope with their lifetimes and visibility rules. Students avoid naming conflicts and unintended side effects in multi-function programs.

Lesson 3 • Defining and Calling Functions

Covers return types, parameter lists, function bodies, and the call stack mechanism. Students write functions that encapsulate single, well-defined responsibilities.

Lesson 4 • Recursive Functions

Introduces recursion through base cases, recursive cases, and the call stack's role. Students implement factorial, Fibonacci, and binary search recursively.

Lesson 1 • Sorting and Searching Arrays

Implements bubble sort, selection sort, and linear and binary search on arrays. Students analyse algorithm correctness and apply qsort from the standard library.

Lesson 2 • One-Dimensional Arrays

Covers array declaration, initialisation, indexing, and bounds awareness. Students store and retrieve sequences of values without out-of-bounds errors.

Lesson 3 • Standard String Library Functions

Covers strlen, strcpy, strcat, strcmp, and their safe alternatives from string.h. Students choose the correct function and avoid buffer overflows in string operations.

Lesson 4 • Multidimensional Arrays

Extends array concepts to two-dimensional and higher-dimensional structures. Students represent matrices and grids and pass them correctly to functions.

Lesson 1 • Common Memory Errors and Debugging

Identifies dangling pointers, buffer overflows, memory leaks, and use-after-free bugs. Students use Valgrind and sanitizers to detect and fix memory errors.

Lesson 2 • Pointers to Pointers and Strings

Covers double pointers, arrays of strings, and command-line argument handling. Students manage collections of strings using pointer-to-pointer techniques.

Lesson 3 • Dynamic Memory Allocation

Teaches malloc, calloc, realloc, and free with correct usage patterns. Students allocate heap memory at runtime and resize buffers without leaking memory.

Lesson 4 • Pointer Fundamentals

Introduces address-of and dereference operators, pointer types, and NULL. Students declare pointers, assign addresses, and read values through indirection.

Lesson 1 • Enumerations and typedef

Covers enum for named integer constants and typedef for creating type aliases. Students improve code readability and maintainability with meaningful type names.

Lesson 2 • Unions and Memory Sharing

Explains how union members share the same memory location and when unions are appropriate. Students use unions for type-punning and memory-efficient variant data.

Lesson 3 • Pointers to Structures

Introduces the arrow operator and dynamic allocation of struct instances. Students build linked data structures using struct pointers and heap memory.

Lesson 4 • Nested Structures and Arrays of Structs

Extends structs to contain other structs and to form arrays of records. Students model hierarchical data and iterate over collections of structured records.

Lesson 1 • Bit Fields and Low-Level Techniques

Introduces bit fields in structs, bitwise manipulation patterns, and volatile variables. Students write hardware-oriented code that controls individual bits efficiently.

Lesson 2 • Binary File I/O

Teaches fread and fwrite for structured binary data and fseek for random access. Students serialise and deserialise struct data to and from binary files.

Lesson 3 • The C Preprocessor in Depth

Explores macros, conditional compilation, and include guards beyond basic usage. Students use the preprocessor to write portable, configurable code.

Lesson 4 • Error Handling Strategies

Covers errno, perror, strerror, and return-code conventions for robust error propagation. Students design functions that report failures clearly without crashing.