Student Reference¶
Everything on this page is meant to sit open beside your editor. These are not teaching material: if a sheet does not immediately make sense, read the module it belongs to and come back. A sheet compresses what you already understand.
Each sheet is deliberately short, precise and example-driven: a rule, the smallest example that shows it, and the one thing people most often get wrong.
The reference pages¶
Language and classes¶
| Sheet | Covers | Pairs with |
|---|---|---|
| C++ OOP Quick Reference | The whole language surface this course uses on one page: a class, the five special members, every keyword that changes dispatch or lifetime, the build command | Module 1 |
| Class Design | Responsibilities, invariants, interfaces, const-correctness, and the four ways a class leaks its representation |
Module 2, Module 4 |
| Constructors and Destructors | Every constructor form, initialiser lists, explicit, = default, = delete, and construction and destruction order |
Module 3 |
| Inheritance | is-a versus has-a, the three access modes, name hiding, diamonds, final, using Base::Base |
Module 6 |
| Polymorphism | virtual, override, final, dynamic versus static binding, the virtual destructor rule, slicing, polymorphic containers |
Module 7 |
Ownership, the library, and failure¶
| Sheet | Covers | Pairs with |
|---|---|---|
| Rule of Zero, Three and Five | What the compiler generates, when, the decision table, copy-and-swap, and how to reach the Rule of Zero | Module 10 |
| Smart Pointers | unique_ptr, shared_ptr, weak_ptr, custom deleters, cycles, and when a raw pointer is correct |
Module 11 |
| The STL | Which container for which operations, complexity, the algorithms you actually use, lambdas, and iterator invalidation | Module 14 |
| Exception Handling | throw/try/catch forms, hierarchies, noexcept, the three guarantees, and exception-safe cleanup |
Module 13 |
Design¶
| Sheet | Covers | Pairs with |
|---|---|---|
| SOLID | The five principles, each with the smell it prevents, the fix, and its cost | Module 15 |
| Design Patterns Quick Reference | The patterns this course uses, the requirement that earns each one, and the alternatives worth declining | Module 15 |
Troubleshooting¶
| Sheet | Covers | Pairs with |
|---|---|---|
| Common Compiler Errors | The messages you will actually hit — syntax, names, types, classes, linking, warnings — with the fix for each, captured from the course toolchain | Reading Compiler Errors |
| Common OOP Bugs | Slicing, missing virtual destructors, silent non-overrides, double frees, dangling pointers, leaks, and exception mistakes — with real output | Module 16 |
| Debugging Checklist | An ordered procedure: reproduce, locate, understand, fix, verify — plus the traps that make bugs disappear | Module 16 |
Vocabulary¶
| Reference | Covers |
|---|---|
| Glossary | Every term the course uses, defined precisely, grouped by module — and a debugging vocabulary section |
How to use a reference page properly¶
Do not use one to learn a topic. A sheet compresses what you already understand. Reaching for it before reading the module produces the illusion of knowing: you recognise the syntax, so you assume you know the rule, and the rule is the part that is examined.
Use one to remove friction. Forgetting whether override goes before or after the parameter
list is not a knowledge gap worth carrying in your head. Look it up, carry on.
Use the troubleshooting pages in order. Common Compiler Errors is for when the compiler refuses your code. Common OOP Bugs is for when it compiles and misbehaves — the far more dangerous case, because nothing tells you. The Debugging Checklist is the procedure that connects the two.
Write your own. By Module 8, you will know the five things you keep getting wrong. A sheet containing those five things is worth more than any of these, because it is aimed exactly at your gaps. Keep it in your mistakes file — see Study Plan.
Prefer the primary source for signatures. These pages state rules and reminders. For an exact signature, an overload set or a corner of behaviour, use cppreference — see Further Reading.
Still to come¶
The sheets above cover the fifteen topics in this section. A few narrower sheets are planned as
their modules are revised — compiling and running on each platform, const in full, operator
overloading, static members, templates, complexity tables, UML notation, file I/O and
multi-file builds. Where those topics arise in the sheets above, the sheet links to the module
that teaches them properly rather than duplicating it.
Related: Glossary · Reading Compiler Errors · Assessments · Projects · Study Plan