C++ Programming

C++ rewards learners who want to understand what their program is actually doing. It keeps the low-level machinery of memory and lifetime visible, and then gives you the tools — classes, containers, algorithms and RAII — to build on top of it without repeating that work by hand.

This is an intensive foundations programme for people who are new to programming, and for learners who have written some C or C++ informally and want to close conceptual gaps. The course builds progressively from small console programs to a modular command-line application.

Participation requirements

No prior programming knowledge or prior Deesha course is required. Learners need regular access to a 64-bit Windows, Linux or macOS computer, basic file-and-folder skills, and permission to install or use the course toolchain. Plan approximately 30–45 minutes of practice after most sessions and up to 90 minutes between final-project sessions; this practice is recommended for fluency and is not counted in the 40 guided hours.

Who should choose a different course

This course is not intended for experienced C++ developers who already work confidently with templates, move semantics and multi-file builds. It also does not teach template metaprogramming, concurrency, coroutines, ranges in depth, graphics or game frameworks, Qt, operating-system internals, or performance engineering. Those belong in focused follow-on programmes after the language foundation is secure.

If you want to learn programming through the smallest possible language surface, DTA-16 C Programming covers the same foundations with no classes or standard library. Neither course is a prerequisite for the other; they are two routes into the same territory.

Language standard and toolchain

The course uses ISO C++20 as the current language reference while compiling all required exercises with an explicit C++17-compatible portability profile. Selected C++20 improvements may be demonstrated as optional awareness, but learners are never assessed on a feature that is not dependably available in the supported GCC and Clang environments.

Learners use a current stable GCC or LLVM/Clang toolchain with GDB or LLDB. The planned pilot environments are MSYS2 UCRT64 GCC on Windows, GCC on Linux and Apple Clang on macOS. Each must pass the clean-machine release checklist before the first batch. Early exercises invoke the compiler directly so diagnostics, compilation and linking remain visible. The final project introduces CMake for a reproducible multi-file build.

Development environment options

1. Recommended: Visual Studio Code with the C/C++ tooling, LLVM/Clang, a debugger and CMake Tools. This keeps the setup free and lightweight while exposing the real build and debug workflow.
2. Alternative: CLion with a configured LLVM/Clang or GCC toolchain. It provides a more integrated project, CMake and debugging experience, but has higher system requirements and must be used under an appropriate JetBrains licence.

How each session works

Each two-hour session follows a consistent rhythm:

• approximately 35 minutes of concept explanation and live demonstration
• approximately 70 minutes of guided and independent coding
• approximately 15 minutes of review, debugging discussion or a short formative learning check

The balance changes during final-project sessions, when most of the time is used for implementation, review and correction.

Final applied project — Campus Library Desk CLI

Learners build a domain-neutral command-line application for recording and managing borrowable campus items and their loans. The brief requires no specialist library knowledge and gives learners clear acceptance criteria, starter interfaces and sample data without giving them the completed implementation.

The project requires learners to:

• model items behind an abstract interface, with at least two concrete kinds
• keep loan and member records in standard containers chosen for the access pattern
• provide a menu with robust, line-based input and clear validation errors
• add, list, find and update records using standard algorithms
• own any dynamic resources through RAII rather than manual delete
• save and reload data from a documented text or CSV format
• separate data, workflow, input/output and utility responsibilities across headers and sources
• compile without warnings under the course flags and handle file or input failures with exceptions caught at the application boundary
• include a README, sample data and a short learner demonstration

Recommended depth and boundaries

Classes and object lifetime

Classes are taught deeply enough for learners to design a type with a clear invariant, initialise it correctly, keep member functions const where they should be, and reason about when destructors run. Operator overloading is limited to what a project genuinely needs; conversion operators and custom allocators are outside the required scope.

Resource ownership

Learners practise RAII, std::unique_ptr and non-owning raw pointers, and see std::shared_ptr demonstrated with its cost explained. Move semantics are introduced as awareness — what std::move signals and why the rule of zero is the default — rather than as a hand-written rule-of-five exercise.

Templates

Function templates and the reading of simple class templates are required, because the standard library cannot be used without them. Writing generic libraries, template specialisation, SFINAE and concepts are reserved for follow-on programmes.

Standard library

Required coverage is std::string, std::vector, std::array, std::map, iterators, and the common algorithms used by the project. Ranges, views, std::span, concurrency primitives and filesystem APIs may be demonstrated as extensions but are not required in this foundations course.

Assessment and completion

Each session includes a formative learning check. The required final quiz is delivered in Moodle; session checks may also be assembled there after platform import review. Course completion requires:

• at least 80% attendance
• at least 60% on the required final quiz, with a maximum of two attempts

For the pilot batch, attendance and the final quiz are recorded and verified manually by the trainer. Automated tracking arrives with the learning platform; the completion criteria above are the same either way.

The final project is reviewed and demonstrated as applied learning evidence, but it is not an additional completion gate for this pilot. The completion record therefore confirms the attendance and knowledge-check criteria above; project evidence is recorded separately and does not claim an independently certified level of professional capability. This course does not provide a certification.

Learning materials

Active enrolled learners receive session study guides, starter files, exercises, the course quick reference and interview-preparation material. Approved session recordings may be provided when a batch records them with the required notice, consent, review and access controls. Learner material is shared through restricted access. Study material is view-only where the platform supports it; starter code and exercise data are downloadable so learners can compile and edit a personal working copy. Trainer plans, source presentations, solutions and question rationales remain private.

Interview-preparation material

Learners receive supplementary material covering common foundation-level C++ questions and code-reading exercises. It will be exported to an accessible participant format before release. This material supports revision; the course does not promise interview or employment outcomes.