Skip to content

All Modules

Sixteen modules, in order. Each one assumes the modules before it, so the safest way to work is straight through. The course moves from understanding why object orientation exists, to building and relating objects, to designing and testing a complete application.

Recommended pace: one module per week, with the lab finished before moving on. See Study Plan for other schedules.

The module table

# Module What you learn Prerequisite Levels
1 C++ and the OOP Mindset How source becomes a running program; procedural vs object-oriented decomposition; the four pillars; finding classes in a problem description — L1 → L4 (exit L3)
2 Classes and Objects class and struct; data members and member functions; access specifiers; this; headers and source files 1 L1 → L4 (exit L3)
3 Constructors and Destructors Object lifecycle; member initialiser lists; explicit; = default and = delete; construction and destruction order 2 L1 → L5 (exit L4)
4 Encapsulation Invariants; information hiding; const-correctness; friend; accessors versus capabilities; cohesion and coupling 3 L2 → L5 (exit L5)
5 Operators and Static Members Operator overloading rules; << == < []; assignment versus copy construction; class-level state with static 4 L2 → L5 (exit L4)
6 Inheritance Is-a; public, protected and private inheritance; construction order; multiple inheritance and the diamond; inheriting constructors 5 L3 → L5 (exit L5)
7 Polymorphism virtual; override and final; dynamic binding; object slicing; virtual destructors; virtual dispatch internals 6 L3 → L6 (exit L5)
8 Abstract Classes Pure virtual functions; abstract classes versus interfaces; design by contract; keeping hierarchies shallow 7 L4 → L6 (exit L5)
9 Composition and Association Has-a; composition, aggregation and association; ownership; forward declarations and include cycles; exposing collections safely 8 L4 → L6 (exit L5)
10 Copying and Resource Management Shallow versus deep copy; the Rule of Three, Five and Zero; lvalues, rvalues and move semantics; copy elision 9 L4 → L7 (exit L7)
11 RAII and Smart Pointers RAII; unique_ptr, shared_ptr, weak_ptr; ownership transfer; reference cycles; custom deleters 10 L4 → L7 (exit L7)
12 Templates Function and class templates; deduction and instantiation; specialisation; generic programming versus polymorphism 11 L4 → L6 (exit L6)
13 Exception Handling throw, try, catch; propagation and unwinding; custom exception hierarchies; noexcept; exception safety guarantees 12 L4 → L7 (exit L6)
14 The STL with OOP Containers; iterators; algorithms; lambdas; making your own types work in standard containers; complexity-based choice 13 L3 → L7 (exit L7)
15 SOLID and Design Patterns UML class diagrams; the SOLID principles; dependency injection; factory, adapter, decorator, strategy, observer, template method 14 L5 → L8 (exit L8)
16 Advanced OOP Capstone Multi-file architecture; namespaces; streams and file persistence; testing; refactoring a complete system 1–15 L5 → L8 (exit L8)

The Levels column is the range of cognitive difficulty each module works across, from L1 Understand to L8 Evaluate. The exit level is what you should be able to demonstrate before moving on — you do not have to master the top of the range on a first pass. Every module page states its own range, and the eight levels are explained in How You Will Learn.

The four arcs

The numbering is not arbitrary. The modules come in four arcs, each answering a question the previous one raised.

Arc Modules The question it answers
Foundations 1–4 What is an object, and how do I write one that cannot be misused?
Building objects well 5–8 How do my types behave like built-in types, and how do I express specialisation and variation?
Objects relating to objects 9–12 Who owns what, how do objects cooperate, and how do I control copying and lifetime?
Professional practice 13–16 How does a complete, changeable, tested application get built?

How each module is structured

Every module has the same sections, so you always know where to look:

  • Introduction — what the module is for, its prerequisites and objectives
  • Concepts and explanations — the teaching text
  • Worked examples — short programs with the reasoning shown
  • Code examples — programs in examples/, with captured output
  • Exercises — three tiers
  • Lab — one increment of the running system
  • Challenge problems — open-ended design prompts
  • Self-assessment — a quiz
  • Summary — what you must retain
  • Further reading — books and official documentation

The labs build one system

The sixteen labs are not sixteen exercises. They extend a single program — a campus library lending system — from a deliberately clumsy procedural version in Lab 1 into a designed, tested, persistent application in Lab 16.

That structure is deliberate: you experience the problem before you are handed the solution. The procedural version hurts, so encapsulation makes sense. Adding a second kind of item hurts, so inheritance has a reason. Managing memory by hand hurts, so RAII is a relief.

Where to go next