• Format — 1,400+ free MCQs with instant explanations after every wrong answer.
• Duration — about 16.3 hours of focused practice; most learners finish over 3–5 weeks at 45–60 minutes a day.
• Level — intermediate. Assumes C++ fundamentals (pointers, references, classes, templates) and ideally C++ Modern Features (auto, range-based for, lambdas) which make STL idioms read cleanly.
• Cost — free, with a free completion certificate.
• Audience — working C++ developers writing data-structure-heavy services, candidates preparing for product-company and competitive-programming C++ interviews, engineers in trading, graphics, and systems work, and college students prepping for placement DSA rounds in C++.
• Recommended before this — C++ Fundamentals and C++ Modern Features.
• Companion course — C++ Templates & Advanced for the deep template territory behind the STL's design.

Four audiences specifically. First, working C++ developers using vector and map daily but who have never sat down with the full STL — the engineers who reach for unordered_map by reflex and would not have a good answer if asked when std::map's ordered iteration is the better choice. Second, candidates preparing for C++ interviews at product companies and trading firms, where container selection is a standard filter (priority_queue for top-K, set for ordered range queries, unordered_map for cache-style lookup). Third, competitive programmers prepping for ICPC and online-judge contests where STL fluency is the difference between fitting a solution in time and not. Fourth, engineering students preparing for placement DSA rounds in C++ where the STL is the standard library you build solutions on.

This course assumes C++ Fundamentals — classes, templates, references. Ideally also C++ Modern Features — STL usage with auto, range-based for, and lambdas is dramatically cleaner than the C++98 equivalent. Take both first if you haven't.

The STL design and sequence containers

• Introduction to the STL — the STL overview, the trinity of containers / iterators / algorithms, container categories, and the iterator-driven algorithm philosophy that makes the whole library compose.
• std::vector — vector basics (the workhorse container), capacity and memory (reserve vs resize, push_back amortised cost), and vector operations including the iterator-invalidation rules every C++ dev meets the hard way.
• Sequence Containers — std::deque (double-ended, segmented), std::list and std::forward_list (linked, splice-friendly), std::array (fixed-size, zero-overhead).

Associative containers and adaptors

• Associative Containers — std::set and std::multiset, std::map and std::multimap, the red-black-tree internals that give O(log n) operations, and Comparator requirements (strict weak ordering).
• Unordered Containers — std::unordered_map and std::unordered_set, the hash-table internals (buckets, load factor, rehash), and how to write a correct custom hash function for your own types.
• Container Adaptors — std::stack and std::queue (typically over std::deque), std::priority_queue (a heap over std::vector by default), and the underlying-container template parameter that lets you customise their performance.

Iterators, algorithms, and the glue

• Iterators — the five categories (input, output, forward, bidirectional, random-access), iterator operations (advance, distance, next, prev), and the invalidation rules each container exposes.
• STL Algorithms — sorting (sort, stable_sort, partial_sort, nth_element), searching (find, binary_search, lower_bound), and the transforming/numeric algorithms (transform, accumulate, partition, iota).
• Function Objects & Predicates — pre-defined functors (less, greater, plus, multiplies), std::function for type-erased callables, std::bind, and lambdas as the modern replacement that beats hand-rolled functors most of the time.
• Pairs, Tuples & Utilities — std::pair, std::tuple, std::make_pair / std::make_tuple, std::tie for assignment-style unpacking, and the structured-bindings-friendly modern usage.
• STL Mastery in Practice — container comparisons (vector vs deque; map vs unordered_map; set vs unordered_set; priority_queue vs sorted vector), pattern selection (which container for which problem), and STL in real production code.

The single most-asked C++ container question and one this course gives you a real answer to. std::map is a red-black tree — O(log n) operations, ordered iteration, range queries via lower_bound / upper_bound / equal_range, and a Comparator template parameter. Pick it when ordering matters or range queries are required. std::unordered_map is a hash table — average O(1) operations, no ordering, requires a hash function (and equality predicate) for the key type. Pick it for plain lookup, especially at high element counts.

The course works through this with output-prediction questions (does this iteration order match? — for std::map yes, for std::unordered_map no), pattern questions (which container for this rate-limiter? this LRU cache? this leaderboard?), and trap questions (this unordered_map with a broken hash function silently slows from O(1) to O(n) — where's the bug?). The Associative Containers, Unordered Containers, and In Practice topics drill these comparisons until pattern selection is reflex.

Active recall on real container and algorithm code, not skimming the cppreference complexity table. Most working C++ devs know vector is O(1) push_back amortised but cannot explain when push_back invalidates iterators, why std::list is almost never the right choice despite its O(1) insertion claim, or which algorithm is stable. MCQ practice forces production every question. Spacing matters too — 45–60 minutes a day for 3–5 weeks beats one cram weekend, because the STL has enough small rules (iterator invalidation per container, complexity caveats, comparator requirements) that each one only sticks after multiple rephrasings.

One question at a time. You read a snippet (often a 10–15 line block that builds, mutates, and iterates a container), pick the option matching the resulting state, iteration order, or thrown exception, and submit. Wrong answers trigger an explanation that walks through the actual mechanic — the rehash that invalidated the iterator, the broken Comparator that lost transitivity, the priority_queue's underlying-heap behaviour, the unordered_map's hash-collision chain.

The Abekus AI guide watches which topics you keep getting wrong and surfaces them more often. If you nail vector but keep mis-predicting unordered_map rehash behaviour, the next session leans on Unordered Containers. The certificate is gated on completing every top-level topic, so the depth signal is honest.

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

Most learners spread that across 3–5 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 — iterator-invalidation rules, container complexity caveats, and Comparator transitivity only stick after the same trap has been rephrased multiple ways.

This course assumes C++ Fundamentals and is much smoother after C++ Modern Features — auto, range-based for, and lambdas make STL idioms dramatically cleaner. If you skipped Modern Features, you can still take this course but expect to fight the syntax. After STL Mastery, the natural next step in the C++ Mastery track is C++ Templates & Advanced, which covers the template metaprogramming that the STL itself is built on — once you understand how the STL works, building libraries with the same techniques becomes accessible.

For candidates interviewing across languages, Java's Collections framework is the rough equivalent of the STL containers — comparing the two sharpens intuition for both. Python's dict, list, set, and collections module are higher-level analogues; seeing what C++ gives up for performance and what Python gives up for ergonomics is illuminating.