C++ FUNDAMENTALS · INDEPENDENT PATH
We explain new ideas in plain language, practise repeatedly and build useful projects. No previous coding course is required.
std::cout << "Hello, learner!\n";Your first useful result is only a few careful steps away.EXPLORE BEFORE YOU START
A beginner-first C++ course that grows from simple console programs to reusable classes, standard-library tools and complete projects.
No previous programming course is required. Begin with the first section and learn the vocabulary before moving to larger programs.
You can read this outline without signing in or completing onboarding. Start with the welcome screen above when you are ready to practise. Use a current browser; a keyboard and larger screen can make longer coding tasks easier, but the lesson interface also adapts to phones.
The in-page coding checks look for required patterns; they do not compile or execute C/C++. Use a suitable compiler to verify syntax, input, output and memory behavior. Each section combines explanations, practice, projects and a ten-question exam.
Read an explanation, study the example, try the task and review feedback. Keep your own project files and test them in their intended environment. Completing an activity or a course certificate is not an accredited qualification or a guarantee of employment.
Expand a section to read its chapters and projects. This is the actual course curriculum, not a separate list of promised future topics.
Start from zero: understand programs, compilation, the shape of a C++ source file and readable console output.
Section outcome: Explain and write a small C++ program with clear console output.
Understand precise instructions, the role of a programming language and why C++ is widely used.
Learn what the compiler and linker do before a C++ program can run.
Rebuild and vary the from .cpp source to a running program example until every important piece feels familiar.
Read the structure of a small C++ program one symbol at a time.
Use build messages as clues and write comments that help the next reader.
Rebuild and vary the errors, warnings and comments example until every important piece feels familiar.
Create a clear multi-line introduction with C++ streams.
Turn a real communication need into a complete C++ console program.
Name changing values, choose expressive types, read complete input and calculate without accidental data loss.
Section outcome: Build small interactive C++ calculators and explain every conversion.
A C++ variable is a named object with a type; const prevents changes after initialisation and communicates intent.
C++ provides arithmetic and Boolean types, while std::string manages text more safely and conveniently than a raw character array.
Rebuild and vary the numbers, bool, char and std::string example until every important piece feels familiar.
std::cin extracts formatted values, std::getline reads a whole line, and stream state reveals whether conversion succeeded.
Expressions follow precedence rules and type conversions; explicit casts make a deliberate conversion visible at the exact point it is needed.
Rebuild and vary the operators, precedence and safe conversions example until every important piece feels familiar.
Read quantity and unit price, apply a clear tax rate and print an itemised total.
Collect labelled income and expenses, calculate the balance and warn when spending exceeds income.
Turn rules into branches and repeat work with traceable loop state.
Section outcome: Build menu-driven programs with validated decisions and bounded repetition.
Comparisons create true or false conditions; logical operators combine them and if selects the matching branch.
Ordered else-if branches handle ranges, while switch handles distinct values; enum class supplies named, scoped states.
Rebuild and vary the else-if chains, switch and enum class example until every important piece feels familiar.
while suits condition-controlled repetition, classic for suits counters, and range-based for visits every element of a collection.
Nested loops process grids or combinations; break exits the nearest loop and continue skips the remainder of one iteration.
Rebuild and vary the nested loops, break and continue example until every important piece feels familiar.
Combine marks, attendance and boundary rules into a transparent course result.
Accept repeated values until a sentinel and report count, sum, average, minimum and maximum.
Create small interfaces with values, references, overloads, lambdas and carefully bounded recursion.
Section outcome: Organise calculations into reusable functions whose effects are explicit.
A function declaration introduces an interface, its definition implements the job and return sends a result to the caller.
Value parameters copy, references can modify caller-owned objects, and const references avoid a copy while preventing mutation.
Rebuild and vary the value, reference and const-reference parameters example until every important piece feels familiar.
Overloads share a name across distinct parameter lists, while a default argument supplies an omitted trailing value.
A lambda defines a small callable near its use; recursion solves a smaller problem until a reachable base case.
Rebuild and vary the lambdas and disciplined recursion example until every important piece feels familiar.
Create and test named functions for common distance and temperature conversions.
Dispatch validated calculator operations to small functions and keep presentation separate.
Work with fixed and growing collections, rich text operations, iteration and standard algorithms.
Section outcome: Choose an appropriate collection and process it without unsafe bounds.
A fixed-size array stores same-type elements; std::array adds standard container features while keeping its size part of the type.
std::string owns text, reports its length, supports searching and can be combined without manual terminator management.
Rebuild and vary the std::string operations and text parsing example until every important piece feels familiar.
std::vector owns a contiguous sequence that can grow, while size and capacity distinguish used elements from reserved storage.
Iterators identify positions in containers, allowing algorithms such as sort, find and accumulate to work across many container types.
Rebuild and vary the iterators and standard algorithms example until every important piece feels familiar.
Measure text, count selected characters and find a word without manual memory handling.
Store a growing set of marks and report sorted values, average, median, lowest and highest.
Create types that protect their own state and expose small, meaningful operations.
Section outcome: Design classes with clear invariants, const queries and composed objects.
A class defines a new type that combines state and operations; an object is one instance of that type.
Encapsulation hides representation behind operations so callers cannot place an object into an invalid state directly.
Rebuild and vary the private state and public interfaces example until every important piece feels familiar.
Composition builds a larger type from member objects whose lifetimes belong to the containing object.
A const member function promises not to modify ordinary object state; static members belong to the class rather than one object.
Rebuild and vary the const member functions and shared class data example until every important piece feels familiar.
Create an Account class whose public operations preserve a non-negative balance.
Model books and a catalogue that can add, list and locate records without exposing its vector.
Create valid objects, reuse genuine is-a relationships and select overridden behaviour safely.
Section outcome: Build a small polymorphic model with correct construction and cleanup.
A constructor establishes a valid object; a member initialiser list constructs each member directly in declaration order.
Public inheritance models substitutability: a derived object is usable where the base interface is expected.
Rebuild and vary the inheritance and is-a relationships example until every important piece feels familiar.
A virtual function enables a call through a base reference or pointer to select the derived override at runtime.
An abstract class describes required operations, and a virtual destructor makes deletion through a base pointer destroy the complete derived object.
Rebuild and vary the abstract interfaces and virtual destructors example until every important piece feels familiar.
Store different shapes through one interface and total their areas.
Model learners, teachers and administrators through a small common Person interface.
Write generic operations and combine standard containers, iterators, algorithms and lambdas.
Section outcome: Solve collection problems with expressive reusable C++ rather than repeated manual loops.
A template describes code in terms of types or values supplied later, allowing one well-tested pattern to serve multiple compatible types.
Standard containers express different data relationships: sequence, key-to-value lookup and unique ordered membership.
Rebuild and vary the vector, map, set and choosing a container example until every important piece feels familiar.
A half-open iterator range [first,last) includes first and excludes last, allowing algorithms to compose safely.
A lambda can express a short comparison or filter beside the algorithm that consumes it, with captures naming outside data it needs.
Rebuild and vary the lambdas, predicates and custom sorting example until every important piece feels familiar.
Count normalised words with a map and report them in a dependable order.
Maintain records, filter low stock and sort reports without exposing container details.
Persist data, report exceptional failures and manage resources automatically with RAII and smart pointers.
Section outcome: Write failure-aware C++ whose files and memory clean up along every path.
ifstream and ofstream manage file handles as objects; stream state indicates whether opening, reading or writing succeeded.
Exceptions separate a detected failure from a suitable handling point; catch specific types and preserve useful context.
Rebuild and vary the exceptions and useful error boundaries example until every important piece feels familiar.
RAII wraps resources inside objects whose destructors release them, making early returns and exceptions safer.
unique_ptr represents one owner, shared_ptr represents deliberate shared ownership, and weak_ptr observes without extending a shared lifetime.
Rebuild and vary the unique_ptr, shared_ptr and ownership example until every important piece feels familiar.
Read simple comma-separated grade rows, report malformed lines and calculate valid averages.
Create, search and persist notes using value types, file streams and clear ownership.
Split interfaces from implementation, test behaviour, reason about algorithms and assemble a complete modern C++ application.
Section outcome: Plan, implement and review a maintainable C++ capstone with persistent data.
Headers declare public interfaces, source files define them and namespaces prevent unrelated names from colliding.
Automated tests compare behaviour with expectations; a debugger observes execution, while assertions protect developer assumptions.
Rebuild and vary the tests, assertions and debugging strategy example until every important piece feels familiar.
Complexity describes how runtime or storage grows; container ordering and algorithm preconditions determine which search is correct.
Value types, automatic resource management, narrow scopes and explicit ownership make C++ easier to review and maintain.
Rebuild and vary the modern c++ habits and code review example until every important piece feels familiar.
Model tasks, update their states and filter a report using standard algorithms.
Combine people, courses, enrolments, reports and persistent storage behind testable interfaces.
Guest progress is saved in this browser on this device. Clearing site data or switching browsers can remove access to that local progress. An optional account can synchronize supported course progress; it is not required to access the lessons. Download or back up project work separately.
Certificates recognize completion of the course activities on this site. They are not university credit, professional accreditation or proof that every program you write is correct.