- Goals of Modern C++
- Major changes from C++11, C++14, C++17, C++20
- How to read the standard and cppreference
- How to maintain this document for future standards
- lvalue / xvalue / prvalue
- Temporary lifetime extension
- Reference collapsing rules
- std::move and std::forward
- decltype rules
- (Future extensions: if upcoming standards adjust value category rules)
- Constructors, destructors, move semantics
- default / delete functions
- noexcept and its role in move operations
- Smart pointers: unique_ptr, shared_ptr, weak_ptr
- enable_shared_from_this & weak_from_this
- Custom deleters and get_deleter()
- Ownership guidelines and common pitfalls
- Stack vs heap vs static storage
- Alignment
- Type layout, triviality, POD vs non-POD
- Object lifetime rules
- Motivation: replacing headers, improving build times
module,export module,import, partitions- Public vs private module partitions
- Header units
- How modules change template compilation
- Organizing a project with modules
- Migrating a CMake project to modules
- Compiler support (GCC/Clang/MSVC)
- (Future extensions: changes from C++23/26/29)
- Template argument deduction
- Function templates vs class templates
- Specialization and partial specialization
- Name lookup (ADL, two-phase lookup)
- Variadic templates
- Type traits and metafunctions
- constexpr, consteval, constinit
- Fold expressions
- Type lists and basic template metaprogramming utilities
- constexpr containers and algorithms
- Immediate functions (consteval)
- Why Concepts exist
- Writing concepts using
requires - Constrained templates and overload resolution
- Common standard concepts (integral, regular, invocable, etc.)
- Designing APIs with concepts
- (Future extensions: any new concepts introduced later)
- Capture modes: =, &, this, *this
- init-capture
- Generic lambdas
- Lambdas as template parameters
- Lifetime and pitfalls
- noexcept and exception guarantees
- When not to use exceptions
- Designing error-return types
- std::expected (C++23)
- Assertions, contracts (future standard proposals)
- Vector/string growth behavior
- List/map/unordered_map internals
- Emplacement semantics
- Allocator and polymorphic_allocator (pmr)
- Container performance characteristics
- (Future extensions from C++23/26)
- std::thread, parameter passing, std::ref
- atomics and memory order
- mutex, lock_guard, unique_lock
- condition_variable
- latch, barrier
- Concurrency design patterns
- Coroutine state machine model
- co_await, co_yield, co_return
- promise_type explained
- Awaitable and Awaiter rules
- Building task, generator, async models
- Using coroutines in networking and database frameworks
- (Future: Executors, networking TS, coroutine extensions)
- const-correctness
- Designing with string_view, span, and other non-owning views
- strong typedefs
- Implicit conversions vs explicit
- ABI stability and pImpl
- Header/module layout guidelines
- std::filesystem
- File streams and performance considerations
- chrono and time APIs
- POSIX sockets overview
- Blocking vs non-blocking
- Epoll/select/kqueue vs async I/O
- (Future: C++ standard networking library when it arrives)
- CMake best practices
- GCC/Clang/MSVC differences
- Sanitizers: asan, msan, tsan, ubsan
- Static analyzers
- perf / valgrind
- GoogleTest basics
- Property-based testing
- Benchmarks and microbenchmarking
- Type erasure (std::function, std::any, custom)
- CRTP patterns
- Optional/variant best practices
- Visitor patterns in Modern C++
- Small object optimization (SOO)
- Designing a lightweight RPC framework
- Designing a database connectivity layer (your picodbc)
- Coroutine-based connection management
- Real-world performance tuning stories
- Summary of what changed in newer standards
- Ranges extensions (C++20/23)
- Reflection proposals
- Pattern matching proposals
- Executor model
- Networking TS adoption
- Notes for upgrading this document
- Cheat sheets (value categories, type deduction rules, template rules)
- Glossary of important Modern C++ terms