C++ Language Course

Lesson 1 • Input, Output, and Basic Debugging

Introduces std::cin and std::cout for console I/O and basic debugging with print statements and compiler diagnostics. Builds habits for iterative development.

Lesson 2 • Compilation and Linking Pipeline

Explains preprocessing, compilation, assembly, and linking as distinct stages. Learners trace how source files become executable binaries.

Lesson 3 • Setting Up the Development Environment

Installs and configures compilers, editors, and build tools on major platforms. Ensures every learner has a reproducible workspace before writing code.

Lesson 4 • Structure of a C++ Program

Dissects the anatomy of a minimal C++ source file, including headers, the main function, and namespaces. Connects syntax rules to the compilation model.

Lesson 1 • Arithmetic and Bitwise Operators

Explores arithmetic, modulo, increment, and bitwise operators with precedence rules. Learners apply operators to solve numeric and bit-manipulation problems.

Lesson 2 • Variable Declaration and Initialization

Distinguishes default, value, copy, and direct initialization forms. Emphasises uniform brace initialization to prevent narrowing conversions.

Lesson 3 • Expressions, Statements, and Undefined Behaviour

Defines sequence points, value categories, and common sources of undefined behaviour. Builds disciplined coding habits from the start.

Lesson 4 • Type Conversions and Casting

Explains implicit promotion, narrowing, and explicit C++ casts. Learners learn to convert types safely without undefined behaviour.

Lesson 1 • Recursion and Stack Considerations

Applies recursion to classic problems and analyses stack depth and tail-call patterns. Learners balance elegance with practical stack limitations.

Lesson 2 • Conditional Statements

Covers if-else chains, switch-case, and the ternary operator with fall-through rules. Learners select the right construct for each decision scenario.

Lesson 3 • Loops and Iteration

Introduces for, while, do-while, and range-based for loops with break and continue. Learners choose loops based on iteration pattern and termination condition.

Lesson 4 • Function Overloading and Name Mangling

Explains how the compiler resolves overloaded function calls and generates mangled names. Learners write overloads that are unambiguous and maintainable.

Lesson 1 • Smart Pointers and Ownership

Introduces unique_ptr, shared_ptr, and weak_ptr as RAII wrappers that automate memory management. Learners replace raw owning pointers with safe alternatives.

Lesson 2 • References and Their Semantics

Distinguishes lvalue references from pointers and introduces rvalue references for move semantics. Learners use references to write efficient, alias-safe code.

Lesson 3 • Common Memory Errors and Sanitizers

Identifies dangling pointers, buffer overflows, use-after-free, and double-delete errors. Learners use AddressSanitizer and Valgrind to detect and fix bugs.

Lesson 4 • Pointers and Address Arithmetic

Introduces pointer declaration, dereferencing, null pointers, and pointer arithmetic. Connects low-level addressing to array traversal and performance.

Lesson 1 • Polymorphism and Virtual Functions

Explains virtual dispatch, vtables, pure virtual functions, and abstract classes. Learners write extensible code that follows the open-closed principle.

Lesson 2 • Classes, Structs, and Encapsulation

Defines class and struct syntax, access specifiers, and member functions. Learners encapsulate data to enforce invariants and hide implementation details.

Lesson 3 • Constructors, Destructors, and the Rule of Five

Covers default, parameterised, copy, and move constructors alongside destructors. Learners apply the Rule of Five to manage resources correctly.

Lesson 4 • Operator Overloading

Overloads arithmetic, comparison, stream, and subscript operators for user-defined types. Learners follow conventions that make overloaded operators intuitive.

Lesson 1 • Class Templates

Defines class templates with member functions, partial specialisation, and default parameters. Learners build generic containers modelled on standard library patterns.

Lesson 2 • Template Metaprogramming Basics

Uses type traits, if constexpr, and compile-time computation to specialise behaviour. Learners optimise code paths without runtime overhead.

Lesson 3 • Variadic Templates and Parameter Packs

Expands parameter packs with fold expressions to handle arbitrary argument counts. Learners implement forwarding wrappers and type-safe variadic utilities.

Lesson 4 • Function Templates

Introduces function template syntax, type deduction, and explicit instantiation. Learners replace duplicated type-specific functions with a single generic version.

Lesson 1 • Utilities: Optional, Variant, and Span

Uses std::optional, std::variant, std::any, and std::span to express nullable, sum, and view types. Learners eliminate null pointer bugs and unsafe unions.

Lesson 2 • Standard Algorithms

Applies sorting, searching, transforming, and partitioning algorithms from <algorithm>. Learners replace hand-written loops with expressive, tested library calls.

Lesson 3 • Strings, String Views, and Formatting

Covers std::string operations, std::string_view for non-owning access, and std::format for type-safe output. Learners handle text efficiently without unnecessary copies.

Lesson 4 • Iterators and Ranges

Explains iterator categories, range-based algorithms, and C++20 ranges and views. Learners compose lazy pipelines that process data without intermediate copies.

Lesson 1 • Move Semantics and Value Categories

Deepens understanding of rvalue references, std::move, and move-only types. Learners eliminate unnecessary copies in performance-critical code paths.

Lesson 2 • Lambdas and Functional Patterns

Defines lambda syntax, capture modes, generic lambdas, and std::function. Learners compose higher-order functions and callbacks with minimal boilerplate.

Lesson 3 • Error Handling Strategies

Compares exceptions, error codes, std::expected, and assertions for communicating failures. Learners choose strategies that balance safety, performance, and clarity.

Lesson 4 • Profiling, Optimisation, and Undefined Behaviour

Profiles with perf and gprof, applies compiler optimisations, and eliminates undefined behaviour using sanitizers. Learners tune code based on measured data.