C and C++ Programming Course: Memory to Modern C++26

This C and C++ programming course is built on one conviction: you cannot write good C++ until you have seen memory with your own eyes. So it starts in C, where nothing is hidden, and only then moves to the abstractions that make C++ productive.

Track A: C, and the machine underneath

C is taught here not as a destination but as a lens. It is the shortest path to understanding what a pointer actually is, what the stack and heap actually are, and what a segmentation fault is actually telling you.

Pointers get the time they deserve. Addresses, dereferencing, pointer arithmetic, the relationship between arrays and pointers, and the precise distinction between a pointer and the thing it points at. Students who rush this struggle with everything afterwards, so the pace here is deliberate.

Then manual memory, including every way it goes wrong: leaks, double frees, dangling pointers, use-after-free. Crucially, these are found rather than described — with valgrind and AddressSanitizer, on the student's own broken code. A bug you have hunted is a lesson; a bug you have read about is a sentence.

The C track closes with C23, the current standard published as ISO/IEC 9899:2024 in October 2024 — binary literals, digit separators, nullptr, typeof, bit-precise integers and the attribute syntax — alongside the practical question of what a student's own compiler supports.

Track B: C++ as its own language

The most common mistake in C++ teaching is presenting it as "C with classes". It is a different language with different idioms, and code written as C-with-classes is usually the worst of both.

RAII is the organising idea. Resource lifetime tied to object lifetime, so that correctness stops depending on remembering to release things. Once a student sees that a well-written C++ program contains almost no explicit delete, the point of constructors and destructors lands properly.

Value categories and move semantics come next, because this is where competent C++ separates from merely working C++. Students learn to spot the copy they did not intend to make, which is the most common performance defect in real codebases.

Then the STL, taught by complexity guarantee rather than by familiarity. Choosing between vector, map and unordered_map is an engineering decision, and students learn to defend theirs.

Templates and concepts follow, so generic code becomes something a student writes rather than only consumes — and so template errors read like English instead of three screens of noise.

Modern C++, and what C++26 actually changes

The course teaches the C++ a 2026 reviewer recognises: auto, structured bindings, optional, variant, string_view, ranges, and CMake as the build system.

C++26 was finalised at the March 2026 ISO meeting, and the headline is static reflection. For the first time C++ can inspect its own types at compile time, which eliminates a large category of boilerplate and the macro machinery previously required to generate it. It is fairly described as the most significant addition since templates, and GCC 16.1 already covers most of C++26, so students compile working examples.

Contracts are taught differently, and deliberately so. They shipped as an explicitly minimum viable product, without support on virtual functions, and the feature is contested inside the committee — Stroustrup recommended against using it as it stands. Students learn what contracts are and why the disagreement exists. Presenting a disputed MVP as settled practice would be teaching them something they would have to unlearn.

Tools, from the first week

A compiler is not a toolchain. Students work with a debugger, sanitisers, a profiler, a build system and version control from early on, because these are what separate someone who can write code from someone who can maintain it.

The habit being built is specific: when something breaks, reach for a tool rather than for a guess. Students who learn to read a stack trace and a sanitiser report stop being blocked by bugs that would otherwise cost them days.

What you build

Each track ends in a substantial program rather than an exam. The C project uses manual memory management with a clean multi-file build and must pass valgrind without complaint. The C++ project uses RAII, templates and the STL, and must be profiled with its container choices justified in writing.

That written justification is part of the assessment. Being able to say why you chose unordered_map over map — in terms of complexity and access pattern — is the skill, and it is what an interviewer is probing for.

Who this suits

Students from Class 9 upward and undergraduates who need C++ for systems work, performance work or competitive programming. Small online groups of up to eight, so code is read closely.

Students whose goal is olympiad selection should pair this with our USACO or INOI courses, which add contest timing and partial-scoring strategy to the language fluency built here.