C++ Beginner
Your first course in modern C++: compile and run real programs, master variables, control flow, functions, collections and the STL, model data with structs and classes, tame pointers safely, and finish by building a tested, multi-file Personal Finance Manager.
65 lessons0 challenges~13 hoursBeginner — no experience needed
Who this course is for
Complete beginners who want a serious foundation, and Python or web developers who want C++'s compiled, statically typed, explicit-lifetime mental model explained from zero.
What you will be able to do
- Write, compile, run and debug modern C++ programs confidently
- Use variables, types, control flow, functions and const correctness
- Choose and use std::vector, std::map, std::set and STL algorithms
- Model data with structs, enum class and well-encapsulated classes
- Explain ownership, lifetime, RAII and smart pointers — and avoid raw new/delete
- Read and write files, test your code, and build a multi-file CMake project
Your First C++ Programs
What C++ is, how compilation works, and your first programs — from hello world to reading real compiler errors like a professional.
Variables, Types & Expressions
Declare, initialize and transform data: primitive types, operators, integer division traps, const correctness, and when auto helps.
Conditions
Branching: if/else chains, boolean logic, and switch — plus the validation mindset that turns input into trustworthy data.
Loops & Repetition
for, range-based for, while, do/while, break/continue, nesting — the machinery of accumulation, search, and validation.
Functions
Decompose programs into named, testable pieces: parameters, return values, pass-by-value vs const reference, overloads.
Strings & Text Processing
std::string as the one string type: indexing, searching, building, and parsing structured text with stringstream.
Collections: vector, map, set
The standard library containers that replace raw arrays: vector growth, associative lookup with map/set, and how to choose.
STL Algorithms & Lambdas
Stop hand-rolling loops: sort, find, count_if, accumulate, reverse — and the lambdas that customize them.
Structs, Enums & Data Modeling
Design your own types: aggregates with structs, safe constants with enum class, and models that read like the problem.
Classes & Object-Oriented C++
Encapsulation with class, constructors that establish invariants, const member functions, and composition-first design — inheritance only where it earns its keep.
References & Pointers
Access without ownership: references as aliases, pointers as addresses, nullptr, and the lifetime question that governs them all.
Memory, RAII & Smart Pointers
Stack vs heap, ownership, RAII, unique_ptr/shared_ptr — and one honest lesson on why raw new/delete are not written in modern code.
Files & Persistence
Programs that remember: ifstream/ofstream, line-based processing, CSV records, and the RAII story you already know.
Errors, Debugging & Testing
Exceptions at boundaries, assertions in development, a repeatable debugging method, and your first test suites.
Multi-File Programs & CMake
How C++ projects really build: headers, translation units, the linker's ODR rules, and your first CMake build.
Architecture & Refactoring
Separating responsibilities, naming that documents, const-correctness as design — and refactoring a mess without breaking behavior.
Git & Professional C++ Workflow
What a C++ repository must ignore, how a build directory changes your commits, and the README that lets strangers build.
Programming Problem Solving
From problem statement to working program: decomposition, edge cases first, complexity intuition, and choosing the structure that fits.
Capstone: Personal Finance Manager
Everything from 18 modules in one artifact: a tested, validated, multi-file-shaped finance CLI. Requirements and acceptance tests — no solution provided.