Loading page
PROGRAMMING COURSE
One complete C++ course in modern style: values and references, ownership and RAII, move semantics, templates, and the standard library — not C with classes.
<iostream>
int main() {
std::cout << "Hello from C++" << '\n';
}COURSE CURRICULUM
Work through a section at a time, or jump straight to the concept you need.
Explain what C++ actually is at the language level, name the domains it still owns, and judge whether a task needs it.
Install a working C++ toolchain and verify it end to end: which g++ answers, which -std is active, and whether libstdc++ headers match.
Write, build, and run a minimal C++ program, and use main's int return value to report success or failure to the shell that started it.
Comment C++ code with // and /* */ knowing exactly where each ends, lay out source freely, and pick identifier names the standard does not reserve.
Follow a C++ build through preprocessing, compiling, assembling and linking, stop it at any stage with g++ flags, and tell compile errors from link errors.
Explain what a translation unit is, why the compiler sees only one at a time, and decide what belongs in a header versus a .cpp.
Use #include and header guards correctly, expand a macro the way the preprocessor does, and replace #define constants with constexpr and inline functions.
Read g++ diagnostics precisely: find the first real error in a cascade, decode a [-Wflag], and fix the warnings that quietly change your results.
Declare variables in C++ with copy, direct, brace, and value initialisation, and know exactly when a variable holds zero, a value you chose, or garbage.
Predict and verify integer widths on any C++ target: know the standard's minimum ranges, spot the LP64/LLP64 split, and pick <cstdint> types deliberately.
Choose between float, double and long double, explain why 0.1 + 0.2 != 0.3, and compare computed floating-point values without relying on ==.
Tell char, signed char and unsigned char apart, handle bytes above 127 without undefined behaviour, and predict how bool converts to and from integers.
Predict what auto deduces from an initialiser and pick auto, auto&, const auto&, or auto* so you get a copy or an alias on purpose.
After this you can introduce readable type names with using, including alias templates, and predict where an alias behaves exactly like the type it names.
Predict and verify the size, alignment and padding of any C++ type, and explain why a struct is usually larger than the sum of its members.
After this you can name the type and predict the value of any mixed-type arithmetic expression in C++ by applying promotion then the usual conversions.
Predict and control which conversions brace initialisation rejects, so value-losing initialisations become compile errors instead of silent bugs.
Declare unscoped enums and enum class types in C++, control their underlying integer type, and convert between an enum and a number deliberately.
Take any object's address with unary &, print it without the char trap, and reason about what C++ actually guarantees about that address.
Create references as second names for existing objects, know what T& and const T& can bind to, and why assignment never rebinds a reference.
Declare pointers, read and write objects through the dereference operator, and reason about pointer arithmetic where +1 moves one element, not one byte.
Decide whether const should freeze a pointer's address, the object it points at, or both, and read any declaration to tell which it does.
Decide between a reference and a pointer by asking whether the target can be missing and whether it can change, then encode that answer in your signatures.