Learn C++

Turn .cpp source files into an executable with a compiler and linker, and switch on the warnings and checks that catch bugs early.

Write a complete program: the main function, printing with std::cout and reading input with std::cin.

Declare variables of the built-in types (int, double, bool, char and friends) and know their sizes, limits and arithmetic rules.

Let the compiler deduce types with auto, and use brace initialization to get safe, uniform initialization without narrowing.

Arithmetic, comparison, logical and bitwise operators, plus the precedence and conversion rules that trip people up.

Control flow with if, switch, while, do-while, classic for and range-based for, including if-with-initializer.

Declare and define functions, pass arguments by value, return results, and understand declarations versus definitions.

Use references as aliases to pass large objects without copying and to let functions modify their arguments.

Give several functions the same name with different parameter types, and make trailing parameters optional with defaults.

Store sequences of values: built-in arrays, fixed-size std::array, and std::vector, the dynamic array you should reach for first.

Work with text using std::string, and pass read-only text cheaply with std::string_view.

Group data and behaviour into your own types with struct and class, member functions and public/private access.

Initialise objects with constructors, clean up with destructors, and tie every resource to an object's lifetime (RAII).

Mark what must not change with const: variables, reference parameters and member functions, so the compiler enforces it.

Build class hierarchies with public inheritance, override virtual functions for runtime polymorphism, and use virtual destructors.

Give your types natural syntax: arithmetic, comparisons with C++20's spaceship operator, and stream output.

Define named sets of constants with enum class, which are scoped, strongly typed and can choose their underlying type.

Transfer resources instead of copying them: rvalue references, std::move, move constructors and copy elision.

Decide which special member functions a class needs, prefer letting members manage resources, and use =default and =delete.

How objects occupy memory: storage versus lifetime, construct_at and destroy_at, alignment and padding, trivial types and bit_cast.

Understand raw pointers: addresses, dereferencing, nullptr, pointer arithmetic, and their modern role as non-owning observers.

Own heap objects safely with std::unique_ptr, share them with std::shared_ptr, and break cycles with std::weak_ptr.

Know what undefined behaviour is, the common ways to trigger it, why optimisers make it dangerous, and the tools that find it.

Control where containers get memory: the allocator model, std::pmr memory resources, arenas and pools.

Write fast C++: measure first, then exploit caches with contiguous data, avoid needless allocations and copies, and prevent false sharing.

Choose between vector, deque, map, set, unordered_map and friends, and use their lookup and insertion APIs correctly.

Traverse any container with iterators, understand half-open ranges and iterator categories, and avoid invalidation bugs.

Write inline function objects with lambdas: captures by value and by reference, generic lambdas, and storing callables.

Replace hand-written loops with std::sort, find_if, transform, accumulate and the rest of <algorithm> and <numeric>.

Use C++20 ranges: algorithms on whole containers with projections, and lazy, composable views joined with |.

Split code into headers and source files, organise names with namespaces, and follow the one-definition rule.

Describe a project with targets in CMakeLists.txt, set the C++ standard and warnings, link libraries and run tests.

How the linker resolves symbols, name mangling, static versus shared libraries, ABI compatibility, extern "C" and the pimpl idiom.

Report errors with throw, handle them with try/catch, and rely on RAII and noexcept for exception-safe code.

Model maybe-values with std::optional, one-of-several types with std::variant and std::visit, and errors as values with C++23 std::expected.

Write generic code with function and class templates, deduction, non-type parameters, CTAD and variadic templates.

Constrain templates with C++20 concepts and requires clauses for clear errors and overloading by capability.

Run code at compile time with constexpr, consteval and constinit, and check assumptions with static_assert.

Compute with types: type traits, SFINAE and enable_if, the detection idiom, if constexpr, and how concepts replace them.

Run work in parallel with std::jthread, protect shared data with mutexes and scoped locks, and use atomics for simple counters.

Understand happens-before, and choose between seq_cst, acquire/release and relaxed memory orders for atomics.

How C++20 coroutines work: the coroutine frame, promise_type, coroutine_handle, awaiters, and C++23 std::generator.