Intermediate C++ Course Uganda – OOP, STL and Algorithms

Course outline and learning expectations

This is a tutor-led course. The outline shows what your tutor will cover; teaching materials and examinations are provided directly to enrolled students.

What you will learn

• By the end of this intermediate C++ programming course, the learner will be able to:
• Design cohesive classes with clear responsibilities and safe interfaces.
• Apply composition, inheritance and runtime polymorphism only where each is appropriate.
• Explain object lifetime, ownership, stack storage and dynamic storage.
• Use RAII and smart pointers to manage resources safely.
• Select suitable standard containers based on access patterns and complexity.
• Transform, search, sort and aggregate data with STL algorithms, iterators and lambdas.
• Write reusable function and class templates with introductory C++20 constraints.
• Represent failures with exceptions, `std::optional` or explicit results as appropriate.
• Organise, build and test a multi-file C++ project with CMake and automated unit tests.
• Evaluate basic time and space complexity and improve an inefficient solution.

Modules

1. 1

   Stronger Types, Interfaces and Class Design

   Review of value types, references, `const` and object lifetimeEncapsulation, invariants and valid object stateConstructors, delegating constructors and member initialiser lists`explicit`, `default`, `delete`, `override` and `final`Separating interfaces from implementation**Practice:** Safer account, customer and transaction types
2. 2

   Composition, Inheritance and Polymorphism

   Composition as the default reuse techniqueWhen public inheritance models a true “is-a” relationshipVirtual functions, abstract interfaces and dynamic dispatchVirtual destructors and object slicingDependency inversion with small interfaces**Practice:** Pluggable transaction-fee or notification policies without web services
3. 3

   Ownership, RAII and Smart Pointers

   Automatic, static and dynamic storage durationDeterministic destruction and RAIIRule of zero and why raw `new`/`delete` are avoided in application code`std::unique_ptr`, `std::shared_ptr` and `std::weak_ptr`Non-owning pointers and referencesFinding memory errors with sanitizers**Practice:** Resource-safe member and asset registry
4. 4

   STL Containers and Complexity

   Choosing among `vector`, `deque`, `list`, `set`, `map` and unordered containersIterators and iterator invalidationKeys, values, hashing and custom comparisonBig-O reasoning for common container operationsMeasuring before changing a data structure**Practice:** Efficient lookup for school, clinic or cooperative records
5. 5

   Algorithms, Lambdas and Ranges

   Prefer standard algorithms to hand-written loops when intent becomes clearer`find_if`, `count_if`, `sort`, `transform`, `accumulate` and partitioningLambda captures and callable objectsC++20 ranges and views at a practical levelComposing readable data-processing pipelines**Practice:** Analyse offline mobile-money or market-transaction records
6. 6

   Generic Programming

   Function templates and class templatesType deduction and `auto`Template specialisation only where justifiedIntroductory C++20 concepts and constraintsGeneric code that remains readable and testable**Practice:** Reusable statistics, validation and repository components
7. 7

   Reliable Programs, Builds and Tests

   Choosing exceptions, `std::optional` or explicit status resultsException safety and RAIIProject structure with headers, source files and namespacesCMake targets and buildsUnit tests, fixtures, boundary cases and regression testsStatic analysis and warning-clean builds**Practice:** Convert an earlier program into a tested, multi-file project
8. 8

   Capstone: Tested Regional Data Processor

   Build one project: SACCO ledger, produce-market analyser or offline transaction processorModel the domain with safe classes and clear interfacesUse appropriate containers, algorithms and at least one reusable templatePersist and reload local dataAdd automated tests and run sanitizersDocument performance choices and demonstrate the final solution