Knowledge baseExam Center
ENEnglish
Choose language13

Learn C++ — Advanced

Design interfaces, collections and algorithms in modern C++. Manage data ownership and lifetimes, and use concurrency, coroutines and explicit report and serialization formats.

COURSE OVERVIEWREADY
Lessons: 60
Quizzes: 10
All steps: 70
$Ready to start
Knowledge base for this technology

What you will learn

  • Build constrained templates, concepts, operators and domain types, separating compile-time requirements from value validation and error handling.
  • Control memory ownership, view lifetimes, object moves and exceptions using RAII, PImpl and appropriately chosen collections and memory resources.
  • Design range algorithms, sorting, aggregation and rankings, and check their numerical boundaries, deterministic output and properties on fixed data.
  • Use atomics, locks, synchronization mechanisms and coroutines, and create explicit text and binary formats, configuration and interfaces with C linkage.

Course curriculum

Work through the curriculum step by step. Completed stages are marked, and you can open the next available stage.

60 lessons10 quizzes70 steps total
  1. 01LESSON
    LESSON 1: Concepts — precise type contracts in C++Available now
  2. 02LESSON
    LESSON 2: Migrating from SFINAE to Concepts (clearer constraints and better diagnostics)Locked
  3. 03LESSON
    LESSON 3: Template parameters: auto, NTTP and CTAD — deducing types and valuesLocked
  4. 04LESSON
    LESSON 4: Parameter packs and fold expressions — aggregating many arguments with a single expressionLocked
  5. 05LESSON
    LESSON 5: The metaprogrammer's toolkit: traits, detection, and type listsLocked
  6. 06LESSON
    LESSON 6: constexpr algorithms in practice — you precompute dictionaries and routing tablesLocked
  7. 01QUIZ
    Quiz 1: lessons 1–6Locked
  8. 07LESSON
    LESSON 7: Consteval, constinit, and inline variables — controlling initialization and the ODRLocked
  9. 08LESSON
    LESSON 8: Static_assert and Diagnostic MessagesLocked
  10. 09LESSON
    LESSON 9: Specializations and Partial SpecializationsLocked
  11. 10LESSON
    LESSON 10: Organizing an API with Namespaces and a detail LayerLocked
  12. 11LESSON
    LESSON 11: ABI-stable interfaces (PImpl)Locked
  13. 12LESSON
    LESSON 12: Strong types and UDL (units, IDs, currencies)Locked
  14. 02QUIZ
    Quiz 2: lessons 7–12Locked
  15. 13LESSON
    LESSON 13: string_view, span, and ownership modelsLocked
  16. 14LESSON
    LESSON 14: Copy vs move in the API: value semanticsLocked
  17. 15LESSON
    LESSON 15: Exceptions, noexcept and guarantee levelsLocked
  18. 16LESSON
    LESSON 16: Object lifetime model, aliasing, alignmentLocked
  19. 17LESSON
    LESSON 17: std::bit_cast, endianness, and bit operationsLocked
  20. 18LESSON
    LESSON 18: std::pmr: memory resources and polymorphic allocatorsLocked
  21. 03QUIZ
    Quiz 3: lessons 13–18Locked
  22. 19LESSON
    LESSON 19: Custom allocators, arenas, and pools — predictable memory managementLocked
  23. 20LESSON
    LESSON 20: Overriding new/delete and over-aligned typesLocked
  24. 21LESSON
    LESSON 21: Data-Oriented Design in C++ — arranging data for the cache instead of OOLocked
  25. 22LESSON
    LESSON 22: Heap vs stack: costs, elision, RVOLocked
  26. 23LESSON
    LESSON 23: Choosing an algorithm: nth_element, partial_sort, lower_boundLocked
  27. 24LESSON
    LESSON 24: Measuring time (<chrono>) without mistakesLocked
  28. 04QUIZ
    Quiz 4: lessons 19–24Locked
  29. 25LESSON
    LESSON 25: Diagnosing “hot spots” without external toolsLocked
  30. 26LESSON
    LESSON 26: Ranges: composing view pipelinesLocked
  31. 27LESSON
    LESSON 27: A custom view adaptor and sentinels — extending ranges with custom transformationsLocked
  32. 28LESSON
    LESSON 28: Projections, comparisons, and the <=> operatorLocked
  33. 29LESSON
    LESSON 29: Ranges vs. classic algorithms — painless migrationLocked
  34. 30LESSON
    LESSON 30: Numeric streams: scans, aggregations, histograms — fast in-memory data analysisLocked
  35. 05QUIZ
    Quiz 5: lessons 25–30Locked
  36. 31LESSON
    LESSON 31: Heterogeneous lookup and transparent comparators — string_view keys in map/set without copyingLocked
  37. 32LESSON
    LESSON 32: unordered_*: custom hash/equal and rehash strategyLocked
  38. 33LESSON
    LESSON 33: Node handles and splicing — moving elements between containers without allocationLocked
  39. 34LESSON
    LESSON 34: Priority queues, heaps, and schedules with SLALocked
  40. 35LESSON
    LESSON 35: Grouping sorted data and equal_range — reports for multiple records with the same keyLocked
  41. 36LESSON
    LESSON 36: Atomics and memory order — you understand happens-before and don't break the memory modelLocked
  42. 06QUIZ
    Quiz 6: lessons 31–36Locked
  43. 37LESSON
    LESSON 37: Fences, atomic_ref, and atomics for shared_ptr – synchronization without mutexesLocked
  44. 38LESSON
    LESSON 38: Mutex, scoped_lock, and shared_mutex — critical sections without deadlocksLocked
  45. 39LESSON
    LESSON 39: Task coordination: counting_semaphore, latch, barrier, stop_token, and jthreadLocked
  46. 40LESSON
    LESSON 40: Parallel algorithms and execution policies — speeding up batches of dataLocked
  47. 41LESSON
    LESSON 41: Coroutines: co_await, co_yield, co_return — readable sequences of asynchronous operationsLocked
  48. 42LESSON
    LESSON 42: Generators built on coroutines (pull/push) — data streams without intermediate buffersLocked
  49. 07QUIZ
    Quiz 7: lessons 37–42Locked
  50. 43LESSON
    LESSON 43: Task/awaitable and composition (when_all/when_any)Locked
  51. 44LESSON
    LESSON 44: Cancellation and timeouts with stop_token — designing a responsive APILocked
  52. 45LESSON
    LESSON 45: The futures ↔ coroutines bridge: integrating std::future with the new styleLocked
  53. 46LESSON
    LESSON 46: std::format and log templatesLocked
  54. 47LESSON
    LESSON 47: std::charconv — fast parsing and formatting of numbers without allocationLocked
  55. 48LESSON
    LESSON 48: Advanced std::filesystem — paths, permissions and the VFS modelLocked
  56. 08QUIZ
    Quiz 8: lessons 43–48Locked
  57. 49LESSON
    LESSON 49: char8_t, UTF-8 and localization pitfallsLocked
  58. 50LESSON
    LESSON 50: Calendars and a fixed UTC offset with <chrono> in C++20 — a deterministic SLA scheduleLocked
  59. 51LESSON
    LESSON 51: Eliminating UB: lifetimes, pointers, and ranges — “always works” instead of “may work”Locked
  60. 52LESSON
    LESSON 52: Contracts without contracts: assert, types, and expectedLocked
  61. 53LESSON
    LESSON 53: Property tests on a deterministic corpusLocked
  62. 54LESSON
    LESSON 54: Failure modes: designing degradation, safe error paths, and retryLocked
  63. 09QUIZ
    Quiz 9: lessons 49–54Locked
  64. 55LESSON
    LESSON 55: Human-friendly compile-time diagnostics – readable errors with concepts and static_assertLocked
  65. 56LESSON
    LESSON 56: C ↔ C++: extern "C", layout and standard-layoutLocked
  66. 57LESSON
    LESSON 57: Boundary design: PImpl and modules — stable boundaries, short builds, clean separationLocked
  67. 58LESSON
    LESSON 58: Serialization without libraries: text/binary, endianness, and <charconv>Locked
  68. 59LESSON
    LESSON 59: Plugins and extensibility: injection points, registries, and loading strategiesLocked
  69. 60LESSON
    LESSON 60: Configuration and feature flags with constexpr/UDLLocked
  70. 10QUIZ
    Quiz 10: lessons 55–60Locked
  71. +EXAM
    Confirm your skills with an examPreparing with this course is optional. You can choose a certification exam for this language and level without completing the course or quizzes. Check your account access and confirm exam authorization.Other status