Programming
Modern C++: From First Program to Concurrency and Templates
Master C++17/20 with RAII, move semantics, the STL, concepts, ranges, threads, and the zero-overhead principle
What you'll learn
- Write idiomatic modern C++ using auto, range-based for, and structured bindings from day one
- Master the STL containers, iterators, and algorithms that solve 90 percent of real problems
- Apply RAII and smart pointers to manage memory and resources without leaks or double-frees
- Use move semantics, perfect forwarding, and value categories to write cost-aware code
- Build generic components with templates, concepts, and compile-time evaluation via constexpr
- Write safe concurrent programs with threads, mutexes, atomics, std::async, and futures
- Compose data pipelines using C++20 ranges, std::variant, and std::optional
- Reason about the stack, the heap, object lifetimes, and the zero-overhead principle
- Read and debug existing C++ codebases across embedded, game, and systems domains
- Navigate the toolchain — compilers, standards, and ISO C++ — with practical confidence
Curriculum
What's inside
6 sections · 43 lectures. Expand each section to see what it covers.
1. First Code: Output, Variables, and the Shape of a C++ Program
- ▸ From C With Classes to ISO C++ Preview
- · Hello, World and the Anatomy of a Translation Unit
- · Variables, Initialization, and the Auto Keyword
- · The Fundamental Types and Their Sizes
- · Arithmetic, Comparison, and Logical Operators
- · Strings, Concatenation, and Reading From the User
2. Control Flow: Decisions, Loops, and Pattern Matching
- · Where C++ Actually Lives Today
- · If, Else If, and the Ternary Operator
- · The Switch Statement and Fallthrough
- · While and Do-While Loops
- · The For Loop and the Range-Based For
- · Break, Continue, and Early Exit
3. Functions, Scope, and the Things They Touch
- · The Zero-Overhead Principle and Its Discontents
- · Declaring and Calling Functions
- · Pass by Value, Reference, and Const Reference
- · Default Arguments and Function Overloading
- · Lambdas: Functions That Travel
- · Scope, Lifetime, and Why Local Pointers Bite
4. Collections: Arrays, Vectors, Maps, and the STL Containers
- · Benchmarks, Footguns, and the Cost of Power
- · C-Style Arrays and std::array
- · std::vector: The Default Container
- · std::map and std::unordered_map
- · Tuples, Pairs, and Structured Bindings
- · Iterators and the Algorithm Library
5. Concurrency, Resources, and Asynchronous C++
- · The Standard, the Compilers, and the Toolchain Reality
- · Threads and Joinable Workers
- · Mutexes, Lock Guards, and the Race Condition
- · std::async, Futures, and Returning Values
- · Atomic Operations and Lock-Free Counters
- · Smart Pointers: unique_ptr, shared_ptr, and weak_ptr
- · Exception Safety and the Stack Unwind
6. Templates, Generics, and the C++20 Toolkit
- · The Memory Model: Stack, Heap, and Object Lifetime
- · Function Templates and Type Deduction
- · Class Templates and the STL Mindset
- · Concepts: Constraining Templates Readably
- · Ranges and Pipeline-Style Algorithms
- · std::variant, std::optional, and Sum Types
- · constexpr and Compile-Time Evaluation
- · RAII: The Best Idea C++ Ever Had
- · Templates, Concepts, and Compile-Time Computation
- · Move Semantics and the Cost of a Copy
- · Design Patterns Reimagined in Modern C++
- · Specialized Domains: Embedded, Real-Time, and HPC
About this course
C++ runs the world you do not see. The game engine rendering your favorite title, the high-frequency trading platform clearing billions in trades before lunch, the browser tab you are reading this in, the firmware in your car's brake system, the database holding your bank balance, the rocket guidance computer that just landed a booster on a barge — all of it is C++. Half a century after Bjarne Stroustrup glued classes onto C, the language is not just alive; it is the quiet giant of modern computing, the one we reach for when nanoseconds matter and abstraction must cost zero. Learning it well is one of the highest-leverage skills a programmer can acquire.
This course takes you from your very first translation unit to the modern C++20 toolkit across six focused sections, without skipping the parts that actually matter. Each coding section opens with a short concept lecture — the history, the big picture, the "why" behind the feature — and then drops you straight into hands-on coding that puts the idea to work. You will write output, variables, the fundamental types, and the operators that bind them, then move through control flow, functions, lambdas, and the STL containers that every working C++ engineer uses daily. You will write your own threads, mutexes, atomics, smart pointers, and exception-safe code, build generic components with templates and concepts, and compose data with ranges, std::variant, std::optional, and constexpr. The course then closes with a run of deeper conceptual lectures — RAII, templates and compile-time computation, move semantics, design patterns reimagined in modern C++, and the specialized domains C++ dominates — that tie everything you have built back to the one question that defines the language: what does this actually cost at runtime?
This course is built for programmers who want C++ as a serious professional tool — career switchers from Python or Java, CS students whose courses skimmed the modern features, embedded and game developers leveling up, and self-taught coders ready for the language that powers infrastructure. You need basic programming familiarity in any language; no prior C or C++ experience is assumed. By the end you will read modern C++ codebases fluently, write idiomatic RAII-driven code, reason about ownership and lifetimes, use templates and concepts without fear, and ship concurrent programs that do not crash at 3 a.m.
What sets this course apart is its refusal to teach C++ as a museum piece. We do not start with raw pointers and char arrays and apologize for them later; we start with auto, vectors, range-based for, and smart pointers, then peel back layers to show what is underneath and why it matters. You will learn the language as it is written in 2026 production code, with the historical context to understand the footguns and the engineering judgment to avoid them. Enroll now and start writing C++ the way the people who maintain compilers, kernels, and trading systems actually write it.
Who it's for
- Python, Java, or JavaScript developers adding a systems language to their toolkit
- Computer science students whose coursework skipped modern C++ features
- Embedded, robotics, and firmware engineers ready to move beyond C
- Game developers, graphics programmers, and engine contributors leveling up
- Self-taught programmers preparing for backend, HFT, or systems interviews
Prerequisites
- Basic programming experience in any language (variables, loops, functions)
- A computer running Windows, macOS, or Linux with at least 4 GB of RAM
- Willingness to install a modern C++ compiler such as GCC, Clang, or MSVC
- Comfort with using a terminal or command prompt for build commands
- No prior C or C++ knowledge required — we build everything from first principles