Learn C++

You'll learn

• CMake — the industry-standard meta-build tool that generates platform native makefiles or Ninja files
• Compiler flags — command-line arguments like -Wall and -Wextra that enforce strict code hygiene
• clangd — the language server protocol daemon providing code completion and error diagnostics

How to work through it

1. 1Install GCC/Clang, CMake, and a modern editor with clangd support
2. 2Write a simple CMakeLists.txt targeting C++20 with strict warning flags (-Wall -Wextra -Wpedantic)
3. 3Build and run your executable from the command line

You'll learn

• Header guards — preprocessor directives (#pragma once) preventing duplicate symbol definitions
• std::cin / std::cout — standard library character streams for terminal input and output
• Translation units — individual source files compiled independently into object files before linking

How to work through it

1. 1Create separate header files for each converter category using `#pragma once`
2. 2Implement function logic in matching .cpp files
3. 3Implement an interactive loop in main.cpp reading user selections via std::cin and std::cout
4. 4Add validation loops to re-prompt on invalid floating-point inputs

You'll learn

• std::mt19937 — standard pseudo-random number generator producing high-quality random values
• std::uniform_int_distribution — maps raw random engine output onto a bounded integer range
• Stream state flags — internal stream condition bits checked via .fail() and reset with .clear()

How to work through it

1. 1Use `<random>` to seed a standard Mersenne Twister engine (`std::mt19937`)
2. 2Write the game loop tracking attempt counts and user guesses
3. 3Check and clear stream error states (`std::cin.clear()` and `std::cin.ignore()`) when parsing fails
4. 4Print formatted post-game statistics upon user quit

You'll learn

• sizeof / alignof — compile-time operators returning byte size and byte alignment requirements
• Struct padding — invisible alignment bytes inserted by compilers to satisfy CPU word alignment
• Fixed-width integer types — explicit size types from <cstdint> such as int32_t and uint64_t

How to work through it

1. 1Define structs with identical member types arranged in descending vs mixed size order
2. 2Print `sizeof` and `alignof` along with member offsets using the `offsetof` macro
3. 3Analyze and document the padding bytes inserted by the compiler

You'll learn

• Pass-by-const-reference — avoids copying large objects while guaranteeing immutability inside the callee
• Lvalue references — aliases to existing memory locations denoted with &
• const correctness — the practice of enforcing compile-time read-only guarantees on variables and parameters

How to work through it

1. 1Implement a function that swaps two custom structs via mutable references
2. 2Implement a function that takes a read-only large struct by `const&` and computes an aggregate score
3. 3Implement pass-by-value variations and step through using a debugger to observe copy behavior

You'll learn

• enum class — strongly-typed, scoped enumerations that prevent accidental implicit conversions to integers
• std::vector — dynamically sized contiguous memory buffer for homogeneous elements
• Range-based for loop — clean syntax for iterating over collections (`for (const auto& item : items)`)

How to work through it

1. 1Define an `enum class GradeLetter` and a `struct StudentRecord`
2. 2Implement functions to calculate GPA by passing records by const reference
3. 3Provide sorting and lookup functions operating over a collection of records
4. 4Render a clean tabular summary in the console

You'll learn

• Pointer dereferencing — accessing or modifying the value stored at a specific memory address via `*`
• Pointer arithmetic — scaling address offsets based on the byte size of the underlying type
• Endianness — the order in which bytes of multi-byte data types are stored in computer memory

How to work through it

1. 1Declare stack arrays and print element memory addresses to observe memory contiguity
2. 2Re-implement array indexing using pure pointer arithmetic `*(ptr + offset)`
3. 3Cast object pointers to `const uint8_t*` to inspect byte-level endianness

You'll learn

• new[] and delete[] — raw operators for heap memory allocation and deallocation in C++
• AddressSanitizer (ASan) — compiler instrumentation tool for detecting out-of-bounds access and memory leaks
• Heap fragmentation and reallocation — copying overhead and pointer invalidation caused by buffer expansion

How to work through it

1. 1Create a struct holding data pointer, size, and capacity
2. 2Implement `push_back` with dynamic buffer reallocation and element copying
3. 3Implement cleanup functions that invoke `delete[]`
4. 4Compile with `-fsanitize=address` to verify zero leaks and zero use-after-free errors

You'll learn

• nullptr — the type-safe null pointer literal introduced in modern C++
• Memory leak — heap memory that was allocated but never freed before dropping the pointer
• Dangling pointer — a pointer referencing a memory address that has already been deallocated

How to work through it

1. 1Define a `Node` struct containing data and a `Node* next` pointer
2. 2Implement `push_front`, `push_back`, `erase(value)`, and `reverse` functions
3. 3Implement a recursive or iterative `clear()` function that deletes every node
4. 4Test thoroughly with an empty list, single element list, and multi-element list

You'll learn

• RAII — tying resource lifecycle strictly to object lifetime via constructors and destructors
• Explicit constructor — preventing unintended implicit conversions by marking single-argument constructors `explicit`
• = delete — modern C++ syntax to explicitly disallow compiler-generated special member functions

How to work through it

1. 1Write a class `FileHandle` taking a file path and mode in its constructor
2. 2Call `fclose` inside the destructor `~FileHandle()` if the handle is valid
3. 3Disable copying by deleting copy constructor and copy assignment operator
4. 4Demonstrate deterministic cleanup when instances go out of scope

You'll learn

• vtable and vptr — the compiler-generated lookup table and pointer used for dynamic dispatch
• override keyword — compile-time check ensuring a member function truly overrides a base class virtual function
• Virtual destructor — ensures that deleting an object through a base pointer invokes the correct derived destructor

How to work through it

1. 1Define `Shape` with pure virtual functions (`= 0`) and a virtual destructor
2. 2Implement derived classes with `override` keyword on all overridden virtual methods
3. 3Store pointers to shapes in an array and iterate to invoke polymorphic behavior
4. 4Observe virtual method table (vtable) dispatch using a debugger

You'll learn

• Access specifiers — `private`, `protected`, `public` control over member accessibility
• Class invariants — conditions that must remain true for an object to stay in a valid state
• Dynamic casting — `dynamic_cast<T*>` for safe runtime downcasting within polymorphic hierarchies

How to work through it

1. 1Design an abstract `Entity` base class and derive `Warrior`, `Mage`, and `Rogue`
2. 2Implement a polymorphic `StatusEffect` system (e.g., Poison, Shield) applied each turn
3. 3Maintain strict private data encapsulation, validating mutations via public methods
4. 4Simulate turn order and display dynamic combat logs in the terminal

You'll learn

• Rvalue references — references to temporary objects denoted with `&&`
• std::move — an unconditional cast from an lvalue to an rvalue expression enabling move constructors
• Rule of Five — if a class declares a custom destructor or copy/move operation, it must declare all five
• Copy-and-swap idiom — an elegant technique to implement strong exception-safe assignment operators

How to work through it

1. 1Implement constructor allocating heap buffer and destructor releasing it
2. 2Implement copy constructor and copy assignment using the copy-and-swap idiom
3. 3Implement move constructor and move assignment operator transferring raw pointer ownership and nulling the source
4. 4Benchmark creating and vector-pushing 100,000 strings with and without move semantics

You'll learn

• Three-way comparison (spaceship operator <=>) — C++20 operator that synthesizes all six relational comparisons
• Friend functions — functions granted access to private members, standard for binary stream operators
• Const member functions — member functions marked `const` guaranteeing they do not mutate instance state

How to work through it

1. 1Implement member compound assignment operators (`+=`, `-=`)
2. 2Implement non-member binary arithmetic operators (`+`, `-`) reusing compound assignments
3. 3Implement C++20 three-way comparison operator (`operator<=>`) for default ordering
4. 4Overload `operator<<` for standard stream output

You'll learn

• Contiguous 1D backing storage — flattening 2D arrays to maximize CPU cache line utilization
• Rule of Zero — designing classes using standard components so no custom destructors or copy/move operations are needed
• Exception guarantees — writing operations that provide basic or strong exception safety

How to work through it

1. 1Store matrix elements in a single contiguous 1D array (`rows * cols`) for cache locality
2. 2Implement constructor, copy/move operations, and destructor satisfying Rule of Five
3. 3Implement `operator()(size_t r, size_t c)` for 2D indexing
4. 4Implement matrix multiplication with boundary dimension checks

You'll learn

• std::unique_ptr — zero-overhead move-only smart pointer ensuring exclusive ownership
• std::shared_ptr — reference-counted smart pointer enabling shared ownership across multiple owners
• std::weak_ptr — non-owning observer pointer preventing reference counting memory cycles
• std::make_unique / std::make_shared — factory functions providing exception safety and optimized allocation

How to work through it

1. 1Model nodes and edges using `std::unique_ptr` for exclusive ownership
2. 2Implement shared references with `std::shared_ptr` and `std::make_shared`
3. 3Break potential reference cycles using `std::weak_ptr` and test `.lock()` access
4. 4Verify destruction orders using debug destructor log outputs

You'll learn

• std::unordered_map — hash table container providing O(1) average lookup time
• std::map — red-black self-balancing binary search tree container providing O(log N) ordered traversal
• Cache locality — CPU hardware caching efficiency favoring contiguous memory like std::vector over linked nodes

How to work through it

1. 1Use `<chrono>` high-resolution clocks to time insertions, lookups, and deletions
2. 2Test contiguous containers (`std::vector`) vs node containers (`std::list`, `std::set`)
3. 3Test sorted associative containers (`std::map`) vs hash tables (`std::unordered_map`)
4. 4Tabulate and analyze execution time and memory scaling curves

You'll learn

• std::list::splice — transfers elements between lists in O(1) time without reallocating nodes
• Iterator validity — understanding which container operations invalidate iterators and which preserve them
• std::optional — return type representing either a valid object or no value (`std::nullopt`)

How to work through it

1. 1Maintain a `std::list` of key-value pairs representing access recency
2. 2Maintain a `std::unordered_map` mapping keys to list iterators for O(1) access
3. 3Implement `get(key)` moving accessed items to the front of the list
4. 4Implement `put(key, value)` with automatic eviction of the least recently used element when over capacity

You'll learn

• Class templates — blueprints for generating type-parameterized classes at compile-time
• Non-type template parameters (NTTP) — passing values (like integers or sizes) as template arguments
• Perfect forwarding — preserving lvalue/rvalue category using `T&&` forwarding references and `std::forward`

How to work through it

1. 1Write a class template parameterized on `typename T` and `size_t Capacity`
2. 2Implement `emplace` using variadic templates and `std::forward`
3. 3Provide copy and move constructors enabled only when `T` supports them
4. 4Test with move-only types such as `std::unique_ptr<int>`

You'll learn

• C++20 Concepts — named compile-time predicates that constrain template arguments
• requires expression — syntax for checking whether arbitrary expressions compile successfully
• Type traits — standard meta-functions from `<type_traits>` for compile-time type inspection

How to work through it

1. 1Define a custom `concept Numeric = std::integral<T> || std::floating_point<T>`
2. 2Define a concept checking whether a type supports serialization via stream operator `<<`
3. 3Apply `requires` clauses to function templates and evaluate compile-time error clarity
4. 4Implement constrained template function overloads

You'll learn

• constexpr — keyword specifying that a function or variable can be computed at compile time
• consteval — immediate functions that are guaranteed to execute only at compile time
• static_assert — compile-time assertion that halts the compiler if a boolean condition evaluates to false

How to work through it

1. 1Write `constexpr` string view parsing helper functions
2. 2Parse key-value integer configuration pairs into a compile-time lookup table
3. 3Use `static_assert` to validate correct parsing and deliberately trigger build errors on invalid input
4. 4Inspect generated assembly on Compiler Explorer (Godbolt) to verify zero runtime parsing cost

You'll learn

• Lambda expressions — anonymous function objects defined in-place with custom capture semantics
• std::transform / std::accumulate — fundamental map and fold operations of the C++ standard library
• Erase-remove idiom — standard technique for removing matching elements from dynamic containers before C++20 `std::erase`

How to work through it

1. 1Replace filtering loops with `std::copy_if` and `std::remove_if`
2. 2Use `std::transform` and `std::reduce` for mapping and aggregation
3. 3Utilize lambda capture lists (`[&]`, `[=]`, `[val = std::move(p)]`) effectively
4. 4Sort complex structs using custom projection lambdas

You'll learn

• Iterator concepts — standard requirements defining forward, bidirectional, and random access iterators
• begin() / end() conventions — defining half-open ranges `[begin, end)` standard across all C++ containers
• ADL (Argument-Dependent Lookup) — compiler lookup mechanism for finding non-member `begin()`/`end()` functions

How to work through it

1. 1Define nested `iterator` struct with `iterator_category`, `value_type`, `difference_type`, and pointer/reference aliases
2. 2Implement `operator*`, `operator->`, prefix/postfix `operator++`, and `operator==`
3. 3Provide `begin()` and `end()` member functions on the tree class
4. 4Pass the tree to standard algorithms like `std::count_if`

You'll learn

• std::views — non-owning range adaptors that perform lazy transformations
• std::string_view — non-owning, lightweight view into a contiguous sequence of characters
• Pipeline operator (|) — syntax for chaining ranges adaptors cleanly

How to work through it

1. 1Read log files as a stream of `std::string_view`
2. 2Construct a processing pipeline using pipe syntax (`| std::views::filter(...) | std::views::transform(...)`)
3. 3Process results lazily without creating intermediary vectors
4. 4Compare pipeline readability and memory usage against traditional loop-based parsing

You'll learn

• std::jthread / std::thread — standard primitives representing OS execution threads (with cooperative cancellation in C++20)
• std::mutex & std::scoped_lock — RAII locking mechanisms preventing race conditions on shared data
• std::condition_variable — synchronization primitive enabling threads to sleep until signaled by another thread
• ThreadSanitizer (TSan) — compiler sanitizer detecting data races and race conditions at runtime

How to work through it

1. 1Spawn worker threads that loop waiting on a shared work queue
2. 2Protect the task queue with `std::mutex` and `std::unique_lock`
3. 3Signal waiting threads when work arrives via `std::condition_variable::notify_one`
4. 4Implement a destructor that signals completion, joins all worker threads, and releases resources

You'll learn

• std::async — executes a function asynchronously and returns a std::future containing the eventual result
• std::future / std::promise — mechanism for transferring values or exceptions between asynchronous threads
• std::thread::hardware_concurrency — queries the number of concurrent hardware execution units supported by the CPU

How to work through it

1. 1Partition input chunks across available hardware concurrency (`std::thread::hardware_concurrency`)
2. 2Dispatch worker tasks via `std::async(std::launch::async, ...)`
3. 3Collect and combine results using `future.get()`
4. 4Benchmark and measure multi-core CPU utilization scaling

You'll learn

• std::atomic — provides lock-free atomic operations guaranteeing freedom from data races
• Memory orders — memory synchronization semantics (relaxed, acquire, release, seq_cst) controlling CPU instruction reordering
• False sharing — performance degradation caused by multiple threads updating atomic variables on the same CPU cache line

How to work through it

1. 1Create a ring buffer with atomic head and tail indices
2. 2Use `std::memory_order_release` when publishing written items
3. 3Use `std::memory_order_acquire` when reading published items
4. 4Verify thread safety and benchmark latency against a mutex-based queue

You'll learn

• Free-list allocator — tracking available memory blocks by embedding pointers inside unused memory chunks
• Placement new — constructing an object at a pre-allocated raw memory address (`new (address) Type(...)`)
• std::pmr (Polymorphic Memory Resources) — modern standard library mechanism for supplying custom allocators to containers

How to work through it

1. 1Pre-allocate a contiguous memory arena of `N * BlockSize` bytes
2. 2Maintain an in-place linked list of free blocks within the unused arena memory
3. 3Implement `allocate()` popping from the free list and `deallocate()` returning blocks to the list
4. 4Benchmark allocation speed against global `malloc` / `operator new`

You'll learn

• CPU cache line — 64-byte chunks loaded into L1/L2/L3 caches; accessing memory sequentially maximizes cache hits
• SIMD (Single Instruction Multiple Data) — hardware instructions processing multiple data elements in a single CPU cycle
• Compiler Explorer (Godbolt) — interactive tool to inspect compiler optimization output across different flags

How to work through it

1. 1Profile the unoptimized code using `perf record` and `perf report`
2. 2Identify cache misses and branch mispredictions
3. 3Refactor loops for cache line locality (tiling/blocking) and enable compiler auto-vectorization flags (`-O3 -march=native`)
4. 4Document the before-and-after profiling metrics

You'll learn

• Systems architecture — combining concurrency, memory management, and networking into a cohesive engine
• Undefined Behavior Sanitizer (UBSan) — compiler tool that flags signed integer overflows, alignment issues, and null pointer dereferences
• Production code standards — building self-contained CMake projects with tests, sanitizers, and clean abstractions

How to work through it

1. 1Implement RAII wrappers for network sockets and file descriptors
2. 2Integrate your ThreadPool to handle client connections concurrently
3. 3Use your LRU cache and custom memory allocator for fast in-memory key storage
4. 4Write a robust command parser using C++20 ranges and string_views
5. 5Enforce zero memory leaks and data races across comprehensive automated integration tests