Functions, Recursion, and Program Organization in C++ Course

Lesson 1 • Setting Up the C++ Environment

Install a compiler toolchain and configure an IDE for C++ development. Establishes the baseline workspace used throughout the course.

Lesson 2 • Core Data Types and Variables

Covers primitive types, variable declaration, initialisation, and type sizes. Provides the data foundation required for all subsequent function work.

Lesson 3 • Operators and Expressions

Explains arithmetic, relational, logical, and bitwise operators with precedence rules. Enables correct expression construction inside functions.

Lesson 4 • Control Flow Statements

Teaches if-else, switch, loops, and jump statements for directing program execution. Prepares students to implement conditional logic inside functions.

Lesson 1 • Parameter Passing Mechanisms

Contrasts pass-by-value, pass-by-reference, and pass-by-pointer semantics. Directly impacts how functions read and modify caller data.

Lesson 2 • Default Arguments and Function Overloading

Teaches default parameter values and overloaded function signatures for flexible APIs. Reduces code duplication while maintaining clear interfaces.

Lesson 3 • Scope, Lifetime, and Storage Classes

Explains local, global, and static variable behaviour within and across functions. Prevents common bugs caused by unintended variable sharing.

Lesson 4 • Inline Functions and the Call Stack

Covers inline expansion hints and how the call stack manages function invocations. Builds intuition for performance and stack-depth considerations.

Lesson 1 • Arrays and Array Operations

Covers one-dimensional and multidimensional array declaration, initialisation, and traversal. Provides the data structures used in recursive and iterative algorithms.

Lesson 2 • References vs. Pointers in Depth

Compares reference and pointer semantics for aliasing, nullability, and reassignment. Guides students towards idiomatic C++ parameter and return-type choices.

Lesson 3 • Pointers and Address Arithmetic

Explains pointer declaration, dereferencing, and arithmetic on contiguous memory. Essential for understanding how arrays decay to pointers in function calls.

Lesson 4 • Dynamic Memory Allocation

Covers new, delete, and heap allocation patterns for runtime-sized data. Prepares students to build data structures used in recursive algorithms.

Lesson 1 • Common Recursive Patterns

Catalogues divide-and-conquer, accumulator, and tail-recursive patterns with examples. Gives students reusable templates for structuring recursive solutions.

Lesson 2 • Recursion Pitfalls and Debugging

Addresses infinite recursion, missing base cases, and stack overflow errors. Equips students to diagnose and fix broken recursive functions systematically.

Lesson 3 • Thinking Recursively

Introduces the recursive mindset: identifying subproblems and trusting the recursive call. Shifts students from iterative to recursive problem-solving patterns.

Lesson 4 • Recursion on Arrays and Strings

Applies recursion to linear data structures using index and pointer parameters. Extends recursive thinking beyond numeric problems to sequence processing.

Lesson 1 • Tree Traversal and Recursive Structures

Introduces binary trees and implements pre-order, in-order, and post-order traversals. Shows how recursive data structures naturally call for recursive algorithms.

Lesson 2 • Binary Search and Recursive Search

Covers recursive binary search on sorted arrays and its logarithmic complexity. Connects recursive structure to measurable performance improvements over linear search.

Lesson 3 • Memoisation and Recursive Optimisation

Introduces memoisation to eliminate redundant recursive calls in overlapping subproblems. Bridges pure recursion to dynamic programming as a performance strategy.

Lesson 4 • Backtracking and Combinatorial Recursion

Teaches backtracking through N-Queens, permutations, and subset generation problems. Develops the ability to prune search spaces and enumerate solutions systematically.

Lesson 1 • Designing Cohesive Modules

Applies cohesion, coupling, and interface-design principles to C++ module boundaries. Produces code that is testable, reusable, and easy to maintain.

Lesson 2 • Build Systems: Makefiles and CMake

Introduces Makefile rules and CMakeLists.txt for automating multi-file builds. Enables students to manage dependencies and build configurations professionally.

Lesson 3 • Namespaces and Name Collision Prevention

Teaches namespace declaration, nesting, and the using directive for managing identifiers. Prevents name collisions in large codebases with multiple contributors.

Lesson 4 • Compilation Units and the Build Process

Explains preprocessing, compilation, linking, and object file generation step by step. Demystifies build errors and prepares students for Makefile and CMake usage.

Lesson 1 • std::function and Type Erasure

Introduces std::function as a uniform wrapper for any callable type. Enables storing and passing heterogeneous callables through a single interface.

Lesson 2 • Function Pointers in C++

Covers function pointer syntax, typedef aliases, and passing functions as arguments. Provides the low-level foundation for callback and dispatch mechanisms.

Lesson 3 • Callbacks, Events, and the Strategy Pattern

Implements callback registration, event dispatch, and the strategy design pattern using callables. Connects language features to real-world software architecture decisions.

Lesson 4 • Lambda Expressions and Closures

Teaches lambda syntax, capture lists, and return-type deduction for inline callables. Enables concise, context-aware function objects without named function overhead.

Lesson 1 • STL Algorithms and Generic Programming

Applies std::find, std::accumulate, std::partition, and related algorithms to containers. Demonstrates how generic programming replaces hand-written loops with expressive code.

Lesson 2 • Template Specialisation and Constraints

Teaches full and partial specialisation and C++20 concepts for constraining template parameters. Produces templates that fail clearly when misused.

Lesson 3 • Variadic Templates and Parameter Packs

Introduces variadic templates and fold expressions for functions accepting any number of arguments. Enables flexible utility functions like type-safe print and tuple builders.

Lesson 4 • Function Template Basics

Covers template syntax, type parameter deduction, and explicit instantiation for generic functions. Eliminates type-specific duplication while preserving full type safety.