Study Plan¶
Self-study fails for one reason more than any other: it is never clear whether you are finished for the day. This page removes that ambiguity. Pick one plan, follow its rhythm, and treat its checklist as the definition of "done".
Choose your pace¶
| Plan | Length | Best for | Time per week |
|---|---|---|---|
| Full semester | 16 weeks | Following a university course, one module per week | 6–8 hours |
| Fast track | 6–8 weeks | You already program in another language and are comfortable with functions and arrays | 10–14 hours |
| Revision | 1–3 weeks | Exams are close; you need consolidation, not first contact | 10+ hours, front-loaded |
All three use the same material. Only the amount per week changes.
Plate 1 — Full semester (16 weeks)¶
One module per week, in numerical order. Do the lab before moving to the next module: the labs accumulate, and each one assumes the previous is finished.
| Week | Module | Lab deliverable |
|---|---|---|
| 1 | 1. C++ and the OOP Mindset | Lab 1 — the deliberately procedural baseline, plus a written reflection on what hurt |
| 2 | 2. Classes and Objects | Lab 2 — first Book and Member classes |
| 3 | 3. Constructors and Destructors | Lab 3 — lifecycle counters, with predictions before running |
| 4 | 4. Encapsulation | Lab 4 — sealed types with enforced invariants |
| 5 | 5. Operators and Static Members | Lab 5 — sortable, searchable, printable domain types |
| 6 | 6. Inheritance | Lab 6 — a family of lendable items |
| 7 | 7. Polymorphism | Lab 7 — one interface, many behaviours; slicing reproduced then fixed |
| 8 | 8. Abstract Classes | Lab 8 — abstract interface and per-kind policies |
| 9 | 9. Composition and Association | Lab 9 — Library and Loan, with ownership diagrammed |
| 10 | 10. Copying and Resource Management | Lab 10 — shallow-copy bug reproduced, then Rule of Five, then Rule of Zero |
| 11 | 11. RAII and Smart Pointers | Lab 11 — ownership converted to smart pointers, with evidence |
| 12 | 12. Templates | Lab 12 — generic repository type used for two record kinds |
| 13 | 13. Exception Handling | Lab 13 — exception hierarchy; nothing leaks on either path |
| 14 | 14. The STL with OOP | Lab 14 — STL-driven queries with complexity justification |
| 15 | 15. SOLID and Design Patterns | Lab 15 — refactor to patterns, with a UML diagram |
| 16 | 16. Advanced OOP Capstone | Lab 16 — the capstone and its design report |
Weekly rhythm
- Read the module's concepts and explanations (1–2 hours).
- Type and run every example yourself — do not copy and paste (2 hours).
- Warm-up and core exercises (1–2 hours).
- The lab, in one sitting where possible (2 hours).
- Quiz; then attempt the module's challenge problem (1 hour).
Finished means: lab builds and runs, quiz answered without notes, the module's challenge attempted (attempted, not necessarily solved).
Plate 2 — Fast track (6–8 weeks)¶
Two modules per week. This works only if you already write code in another language. Compress by doing fewer exercises better, not by skipping labs.
| Week | Modules | Note |
|---|---|---|
| 1 | 1–2 | Do not skip Module 1's reflection — it is the "why" for everything else |
| 2 | 3–4 | Predict constructor/destructor output before running. The surprises are the content |
| 3 | 5–6 | Operator overloading and inheritance together are the classic mid-course bottleneck |
| 4 | 7–8 | Reproduce object slicing deliberately. It is the most misunderstood topic in the course |
| 5 | 9–10 | The Rule of Three → Five → Zero sequence is the single most valuable week in the course |
| 6 | 11–12 | Ownership and generics; expect longer compile times from templates |
| 7 | 13–14 | Exceptions plus STL; these two combine well in one sitting |
| 8 | 15–16 | Design patterns and capstone — budget the full week for the capstone |
Compressed weekly rhythm
- Module A: concepts + core examples + lab (3–4 hours).
- Module A: quiz (30 minutes).
- Module B: concepts + core examples + lab (3–4 hours).
- Module B: quiz (30 minutes).
- Every second week: attempt one challenge problem (1–2 hours).
Finished means: both labs run, both quizzes passed, no module left with a concept you could not have explained to somebody else.
Plate 3 — Revision (1–3 weeks)¶
You are not learning from scratch; you are consolidating. Work backwards from what you will be examined on.
Week 1 — map the territory (fast, low effort)
- Read All Modules and the glossary end to end. Mark every term you cannot define precisely. That list is your work queue.
- Skim each module's summary and cheat sheets. Do not read the long explanations.
- Work through Reading Compiler Errors until every entry is familiar — exam situations punish slow diagnosis.
Week 2 — rehearse the skills that are actually examined
- Do the practice midterms and final under time pressure, with the answer keys closed.
- Re-do the labs' core exercises from a blank file. Reading a solution is not revision; rewriting it is.
- Rebuild your weak list from Week 1. Anything still unclear gets the full module treatment — presumably Modules 7, 10 and 11, which carry most of the marks in a typical exam.
Week 3 — close the gaps
- One-page revision sheets per module, written from memory, then corrected against the module.
- Redo every question you got wrong, without looking at the key first.
- Practise explaining answers out loud. If you cannot say why, you do not yet know it.
Finished means: you can answer the practice final without notes, and you can explain why every answer is right — not only which option is right.
What to do when you get stuck or fall behind¶
Stuck on a concept. Go to the module's worked examples and run them. Then change one thing and predict the result. Concrete code resolves conceptual confusion far faster than reading the same paragraph twice.
Stuck on a bug. Use Reading Compiler Errors, then the "common mistakes" section of the current module, then reduce the problem: comment out code until it builds, and put it back piece by piece.
Fallen behind. Do not skip labs to catch up. The labs are the course; the modules are the vocabulary for them. Instead, drop to the warm-up and core exercises only, and keep every lab. A student who finishes all sixteen labs and half the exercises has learned more than one who raced through every exercise and skipped the labs.
Motivation collapsed. Work on the capstone problem for one session. Building something you actually want is the fastest way back.
Two habits worth more than any plan¶
Predict, then run. Before executing a program, write down what it will print. Being wrong is the moment you learn something.
Keep a mistakes file. One line per bug: what you saw, what caused it, how you fixed it. By Module 10 it will be the most useful document you own — and it will be yours, not the course's.