• Format — 2,000+ free MCQs with instant explanations after every wrong answer.
• Duration — about 23.0 hours of focused practice; most learners finish over 5–7 weeks at 45–60 minutes a day.
• Level — intermediate to advanced. Assumes C++ fundamentals (pointers, references, classes, inheritance, basic templates). No prior modern-C++ experience required.
• Cost — free, with a free completion certificate.
• Audience — working C++ developers modernising legacy codebases, candidates preparing for product-company and systems-role C++ interviews, engineers in trading, graphics, embedded, and game-dev roles, and university students upgrading from C++98-style coursework to modern idioms.
• Recommended before this — C++ Fundamentals (covers the language ground this one assumes).
• Companion comparison — Java for learners crossing over from JVM languages, where the absence of move semantics and manual ownership is the biggest mental-model jump.

Three audiences specifically. First, working C++ developers maintaining or modernising legacy codebases — the engineers who learned the language in C++98 or C++03 and need a structured way to absorb everything between then and C++20 without reading the standard. Second, candidates preparing for C++ interviews at product companies, trading firms, game studios, and systems-role employers — every senior C++ interview now includes move semantics, smart pointers, and lambdas as standard filters. Third, engineering students who learned the C-with-classes subset in coursework and want to upgrade to the language working developers actually write.

This course is not a C++ starter. It assumes you know pointers, references, classes, inheritance, and basic templates. Work through C++ Fundamentals first if you do not yet have that grounding — the first topic introduces modern C++ at a philosophy level but the snippets from Topic 2 onwards expect comfort reading templated function signatures and ownership-bearing code.

The modern C++ vocabulary

• Introduction to Modern C++ — the C++ evolution from C++98 through C++20, the modern C++ philosophy (RAII, value semantics, zero-cost abstractions, type safety), and the deprecation of older idioms.
• Type Deduction — the auto keyword (and its rules around references and cv-qualifiers), decltype and decltype(auto), the difference between decltype(x) and decltype((x)), and modern type aliases with using.
• Lambda Expressions — capture lists (by-value, by-reference, init capture, mixed), generic lambdas with auto parameters, mutable lambdas, and lambdas as STL-algorithm predicates.

Memory and ownership — the C++ that other languages don't have

• Move Semantics & Rvalue References — what rvalue references are, the move constructor and move assignment, the rule of five vs rule of zero, perfect forwarding with std::forward, and the named-return-value optimisation.
• Smart Pointers — std::unique_ptr for sole ownership, std::shared_ptr for shared ownership and the control-block cost, std::weak_ptr for breaking reference cycles, and the make_unique / make_shared idioms.
• Modern Class Features — = default and = delete on member functions, delegating and inheriting constructors, uniform initialisation with braces (and its narrowing-conversion guard), enum class for type-safe enumerations.

Compile-time, concurrency, and the C++17 additions

• constexpr & Compile-time Programming — constexpr functions and variables, if constexpr for compile-time branching inside templates, static_assert for compile-time invariants, and the cases where constexpr beats macros and templates.
• Concurrency Basics — std::thread, std::mutex with lock_guard and unique_lock, std::async / std::future / std::promise, and the safe-publication patterns that prevent races.
• C++17 Vocabulary Types — std::optional for maybe-values, std::variant as a type-safe union, std::string_view for non-owning string references, std::any for type-erased storage.
• C++17 Language Features — structured bindings for tuple and struct decomposition, class template argument deduction (CTAD), if and switch with initialiser, fold expressions, inline variables.
• Modern C++ in Practice — concept comparisons (raw pointer vs unique_ptr; lambda vs functor; class vs struct), pattern selection (when to move, when to copy, when to forward), and modern C++ in real production code.

The single most-asked modern-C++ interview question and one this course makes you stop guessing at. Raw pointers are non-owning references — pass them when ownership is not transferred. std::unique_ptr models sole ownership, has zero overhead over a raw pointer, and moves but does not copy — the default smart pointer for new code. std::shared_ptr models shared ownership with a reference-counted control block — it costs an extra allocation and an atomic increment on every copy, but lets multiple holders share lifetime. Reach for shared_ptr only when shared ownership is actually the requirement; reach for unique_ptr otherwise; reach for raw pointers when you genuinely do not own.

The course works through this with output-prediction MCQs (does this snippet leak?), pattern questions (refactor this raw-pointer code to be exception-safe), and trap questions (this shared_ptr cycle never deallocates — where's the weak_ptr?). The Smart Pointers and In Practice topics drill these comparisons until pattern selection is reflex.

Active recall on real C++ code, not skimming the cppreference pages. Modern C++ is unusually rule-dense — move semantics, perfect forwarding, the rules around auto and decltype, structured-binding behaviour for different kinds of returns — and you do not internalise any of it from one read of Effective Modern C++. MCQ practice forces production every question: predict the output, identify the bug, pick between two idioms under a specific constraint.

Spacing matters too. 45–60 minutes a day for 5–7 weeks beats one cram weekend, because the language has enough small rules (rvalue-to-lvalue collapsing, the exact moment a copy elision happens, when constexpr is implicit) that each one only sticks after multiple rephrasings.

One question at a time. You read a snippet (often a 10–20 line block with a templated function and a few calls), pick the option matching the output, the bug, or the right idiom, and submit. Wrong answers trigger an explanation that walks through the underlying mechanic — the reference-collapsing rule, the copy elision the compiler did or didn't make, the lambda's capture-by-reference that created a dangling pointer, the shared_ptr cycle that leaks.

The Abekus AI guide watches which topics you keep getting wrong and surfaces them more often. If you nail smart pointers but keep mis-predicting structured-binding behaviour, the next session leans on C++17 features. The certificate is gated on completing every top-level topic, so the depth signal is honest.

Plan on roughly 23.0 hours of focused practice. The math: 2,071 active questions × ~40 seconds per question (reading the snippet, picking an answer, skimming the explanation when wrong) = ~1,380 minutes = ~23.0 hours.

Most learners spread that across 5–7 weeks at 45–60 minutes a day. Some compress it into two long weekends; that works for refresh mode but retention is weaker. Trust the spacing — move semantics, perfect forwarding, and the constexpr rules only stick after the same idiom has been rephrased multiple ways.

This course assumes C++ Fundamentals — pointers, references, classes, inheritance, basic templates. If you have not done Fundamentals yet, do that first and come back. After Modern Features, the natural next step in the C++ Mastery track is the STL Mastery course (containers, iterators, algorithms, function objects) — many of the modern features here, especially lambdas and auto, only earn their keep once you are writing real STL-heavy code. After STL, the Templates & Advanced course covers the deep template territory (SFINAE, concepts, template metaprogramming) that senior C++ interviews and library work demand.

For learners crossing over from Java, the gap is mostly mental-model — Java's reference semantics, garbage collection, and lack of operator overloading need active unlearning when moving to modern C++. For Python developers, the type system and explicit memory management are the bigger jumps. Both adjacents sharpen intuition for what makes C++ different.