• Format — 1,400+ free MCQs with instant explanations after every wrong answer.
• Duration — about 15.7 hours of focused practice; most learners finish over 3–5 weeks at 45–60 minutes a day.
• Level — advanced. Assumes C++ fundamentals, modern C++ features (auto, lambdas), and STL familiarity. Templates is the deepest C++ topic and the senior-interview filter at library-heavy shops.
• Cost — free, with a free completion certificate.
• Audience — senior C++ developers writing library code, candidates preparing for staff-level interviews at trading firms, systems shops, and game engines, engineers writing internal frameworks where reusable templates pay off, and library authors maintaining generic infrastructure.
• Recommended before this — C++ Fundamentals, C++ Modern Features, and ideally C++ STL Mastery — the STL is a real-world demonstration of every technique covered here.

Three audiences specifically. First, senior C++ developers writing library code at trading firms, systems companies, game engines, and embedded shops — the engineers whose job is to design APIs that downstream teams use, and where template fluency is the difference between a clean library and an unusable one. Second, candidates preparing for staff-level C++ interviews where the template round is the gate — questions like "implement std::enable_if from scratch", "explain SFINAE", "write a CRTP base for static polymorphism", "deduce the type at this call site" come up verbatim. Third, engineers writing internal frameworks where reusable template machinery (policy classes, traits, tag dispatch) makes the difference between a 200-line and a 2,000-line implementation.

This course is the deepest in the C++ Mastery track and ideally taken last. Take C++ Fundamentals and C++ Modern Features first for the language ground; C++ STL Mastery before this is strongly recommended because the STL is the real-world demonstration of every technique you'll learn here.

Foundations — the template machinery itself

• Introduction to Advanced Templates — the template compilation model (two-phase name lookup), template parameter types (type, non-type, template-template), and why templates live in headers.
• Template Deduction & Instantiation — type deduction in function and class templates, instantiation mechanics (when, what, and how the compiler generates code), and C++17 deduction guides for CTAD.
• Template Specialization — full specialization for fixed types, partial specialization for pattern matching on type shape, specialization techniques, and the specialization-vs-overloading trade-off.
• Variadic Templates — parameter packs, recursive variadic templates, sizeof... operator, and fold expressions (C++17) for compile-time reductions over the pack.

Constraints and patterns

• SFINAE & Type Traits — SFINAE (Substitution Failure Is Not An Error) in its enable_if and trailing-return-type forms, the standard type-traits library, and the std::void_t detection idiom for trait-detection without enable_if ceremony.
• Concepts (C++20) — concept definitions, requires expressions, concept-constrained templates, and the readability and compiler-error-message wins over SFINAE.
• CRTP — the Curiously Recurring Template Pattern for static polymorphism, CRTP applications (mixins, type-safe enable_shared_from_this, statically dispatched virtual-like calls), and the trade-offs against runtime polymorphism.
• Policy-based Design — policy classes for orthogonal behaviour, traits classes for type-driven configuration, template template parameters, and the technique that powers std::allocator and similar STL machinery.

Metaprogramming and advanced idioms

• Template Metaprogramming — compile-time computation (the constexpr-era replacement for the old TMP), type lists and type-list algorithms, metafunction patterns (transformation, predication, reduction over types).
• Advanced Template Patterns — expression templates for fluent DSLs (Eigen and similar matrix libraries), tag dispatch for compile-time function selection, and the senior idioms behind STL-grade libraries.
• C++ Templates & Advanced in Practice — concept comparisons (SFINAE vs concepts; specialization vs overloading; CRTP vs virtual), pattern selection (when each technique is the right tool), and templates in real production code.

Both, but with different priorities by audience. SFINAE is the C++11 technique for constraining template overloads — enable_if, the void_t detection idiom, trailing-return-type tricks. It is verbose, error messages are awful, but it remains everywhere in real-world C++ code and any senior interview will assume you can read it. C++20 concepts are the modern replacement — clearer syntax, dramatically better error messages, expressive requires-clauses. Library code written from 2020 onwards prefers them.

The course covers both. SFINAE first (you need to read it; existing code is full of it), then concepts as the modern way to express the same intent. The In Practice topic includes drills where the same constraint is written both ways so the equivalence is reflex.

Active recall on real template code, not skimming the standard. Templates are the most rule-dense corner of C++ — deduction rules, two-phase lookup, the SFINAE substitution context, overload resolution among specializations and partial specializations — and you do not internalise any of it from one read of any reference. MCQ practice forces production every question: what type is deduced here? Does this overload participate? Which specialization is picked?

Spacing matters too. 45–60 minutes a day for 3–5 weeks beats one cram weekend, because the rule density of templates is unusually high and each rule only sticks after multiple rephrasings. Compile-time error messages are also a learnable skill — the more template code you trace, the faster you can map a 50-line cryptic error to the actual cause.

One question at a time. You read a snippet (often a 10–20 line template definition with a few call sites), pick the option matching the deduced type, the picked specialization, the SFINAE outcome, or the compile-time error, and submit. Wrong answers trigger an explanation that walks through the actual mechanic — the two-phase lookup that found one declaration and not another, the partial-specialization order, the SFINAE substitution that failed silently, the concept-vs-SFINAE equivalence.

The Abekus AI guide watches which topics you keep getting wrong and surfaces them more often. If you nail specialization but keep mis-predicting variadic-template recursion, the next session leans on variadic templates. The certificate is gated on completing every top-level topic, so the depth signal is honest.

Plan on roughly 15.7 hours of focused practice. The math: 1,415 active questions × ~40 seconds per question (reading the template, picking an answer, skimming the explanation when wrong) = ~943 minutes = ~15.7 hours.

Most learners spread that across 3–5 weeks at 45–60 minutes a day. Template questions are denser than most C++ topics — you are often tracing the compiler's deduction or overload resolution — so the 40-second average is conservative. Trust the spacing; SFINAE patterns, specialization ordering, and metaprogramming patterns only stick after seeing each form rephrased multiple times.

This course is the deepest in the C++ Mastery track and ideally taken late. Before this, take C++ Fundamentals for the language ground, C++ Modern Features for the modern syntax most template idioms now use, and C++ STL Mastery for the real-world demonstration of every technique covered here. The STL is essentially a working illustration of policy-based design, type traits, SFINAE, and template metaprogramming — coming to this course after STL means every concept lands on a concrete example you already know.

For library-author-bound engineers, this course pairs with the open-source library codebases worth studying: STL implementations (libc++, libstdc++), Boost, Eigen, fmt, range-v3, abseil. After this course, those codebases become readable rather than impenetrable. For learners crossing over from Java generics, the gap is mostly model — Java's erasure-based generics are far simpler than C++'s code-generating templates, and the mental model shift is what makes templates feel hard at first.