Modern C++

An introduction to native compilation, systems programming, and how C++ maps onto real machines.

A hands on walk through headers, the standard main entry point, streams, and your first compilation command.

Deep dive into the 4 stages of C++ compilation, compiler optimization levels, and troubleshooting common build errors.

Set up a repeatable CMake build, compiler warnings, a debugger, tests, and sanitizers before tackling unsafe code.

Understanding stack storage, value initialization, and why modern C++ prefers brace initialization.

Using standard input/output streams and optimizing console printing speeds for competitive programming.

Understanding type byte widths, signed/unsigned comparisons, and what happens when integers wrap around.

Differentiating runtime and compile-time constants, and using constexpr when constant evaluation is required.

C++20 std::format and C++23 std::print type safe placeholders replacing slow streams and printf buffer risks.

Declaring and defining functions, return values, and understanding pass by value, pass by reference, and pass by pointer.

Organize names, model closed sets of values, control lifetime through scope, and make conversions explicit.

Choose safe fixed-size storage, name complicated types, and unpack tuple-like results clearly.

Using if, else if, else, and switch statements, understanding short circuiting, and exploring hardware branch prediction under the hood.

Exploring execution loop types, iterator bounds safety, and compiler loop unrolling optimizations.

Manipulating binary values directly, compacting boolean values, and hardware bit masking flags.

Understanding how pointers store raw memory addresses, dereferencing variables, and why null pointers crash programs.

How references work as variable aliases, avoiding copy overhead, and the safety benefits of const references.

Comparing automatic stack frames to dynamic heap allocations, memory leaks, and managing allocations.

Separate where a name is visible from how long an object exists, and avoid the lifetime bugs between them.

Struct padding, alignof, alignas, and Struct of Arrays (SoA) vs Array of Structs (AoS) optimizations.

Handle bytes, endian conversion, bit_cast, alignment, and volatile without relying on undefined behavior.

Encapsulation basics, default member visibility rules, and why initializer lists avoid constructor double initialization.

Leveraging RAII to manage system resources, lifetime scopes, and writing custom class destructors.

Differentiating shallow and deep copies, and transferring resources with move constructors and move assignment.

Polymorphism implementation details, virtual table pointers, and the necessity of virtual destructors.

Explaining std::variant, std::any, and std::monostate stack layouts, avoiding virtual table pointer redirection overhead.

Writing type independent functions, template parameters, and how the compiler generates native machine code variants.

Creating generic classes, value parameters, and analyzing std::array compile time sizes.

Overriding templates for specific types, compile time branching using if constexpr, and the vector bool layout optimization hazard.

Restricting template parameters in C++20, requirements checks, and cleaner compiler diagnostics.

Type safe parameter packs (typename... Args) and C++17 fold expansions ((... + args)) to construct custom compile time utilities.

Contiguous arrays vs node allocations, cache line hits, heap reallocation overhead, and when to use deque.

Self balancing tree layouts vs hash table indexes, search complexities, and sorting criteria.

Using iterators as generic pointers, loop boundaries, and the silent crashes of container reallocations.

Avoiding heap allocations with short string buffers and zero copy std::string_view slices.

Iterating over ranges, custom functor objects, and compiler optimizations for lambda captures.

Lazy evaluation ranges pipelines (std::views::transform) and automatic three way comparisons (<=>) in C++20.

Use auto, structured bindings, fixed-width integers, std::span, and explicit conversions without losing safety.

Exclusive resource ownership, zero runtime overhead pointer layouts, and closing files or connections with custom deleters.

Reference counted resource sharing, the physical memory layout of control blocks, and the enable shared from this trap.

Breaking circular reference cycles, holding non owning resource views, and checking lock statuses.

Avoiding double heap allocation steps, cache lines locality, and the make shared constructor trade offs.

Ditching default OS heap latency, memory pool arenas, placement new mechanics, and runtime pmr allocations.

Organize multi-file programs without duplicate definitions, fragile globals, or ABI surprises.

Under the hood compiler exception lookups, binary size overheads, and the runtime latency of stack frame unwinding.

Basic, strong, and noexcept safety guarantees, and writing exception safe code using the copy and swap idiom.

Promising never to throw exceptions, compiler optimizations, and vector copy fallbacks.

Monadic values transmission, returning nullable states, and returning value or error wrappers.

Compile time static checks, runtime sanity testing macros, and compiling out debugging overheads.

Compiler isolated modules (export module, import) vs preprocessor includes, and building clean interfaces.

Moving beyond single file compilation, CMake targets, build directories, and C++ package managers.

Instrumenting code for memory safety using AddressSanitizer (ASan) and measuring microsecond performance.

Use files, time, randomness, callable wrappers, and C APIs with explicit ownership and error boundaries.

Concurrency foundations, creating threads, thread safety scopes, and thread join vs detach rules.

Shared memory race conditions, CPU cache synchronization issues, and securing variables with mutex locks.

Avoiding lock cycles, using scoped lock for multi resource safety, and signaling threads with condition variables.

Returning values from threads, standard futures, promises, and understanding std::async launch policy.

The system overhead of mutex context switches, lock free programming, and hardware std::atomic registers.

Understanding cache coherency protocols, hardware destructive interference, and why adjacent variables destroy thread speed.

Understand C++20 coroutine suspension and C++23 generators without confusing them with threads.

Understanding Single Instruction Multiple Data (SIMD), CPU vector registers, and structuring loops for compiler auto vectorization.

Read compiler vectorization output, inspect assembly in Compiler Explorer, and write a minimal SSE/AVX intrinsic loop.

Build a move only template wrapper enforcing exclusive heap resource ownership and auto cleanup.

Implement a fast bump allocator memory arena that pre allocates heap memory blocks.

Construct a bounded concurrent queue using mutex locks and condition-variable notifications.

Ship a small multi-file application with parsing, bounded concurrency, tests, sanitizers, and a measured performance claim.

A dated, experimental outlook on C++26 proposals and working-draft facilities. Check exact compiler support before use.