“"Excellent question quality and great coverage of advanced C++ concepts."”
Tanya Sharma
Software Developer
CPP-22-02 is short and dense: 40 questions in 65 minutes, plus about 10 minutes upfront for the non-disclosure agreement and tutorial. You sit it at a Pearson VUE test center, and you need 70% — 28 of 40 points — to pass. Each question is worth one point toward your total, and the pass/fail decision is based on your cumulative score across the whole exam, not a block-by-block average, so a weak block can be offset by strength elsewhere.
The question format is single-choice and multiple-choice, often built around short code snippets — you’ll be asked what a given STL call does, what it returns, or which of several candidate function calls correctly solves a stated problem. There’s very little abstract theory; almost everything ties to actual STL syntax and behavior.
Block | Topic | Items | Weight |
|---|---|---|---|
1 | Sequence Containers and Container Adapters (vector, deque, list, queue, priority_queue, stack) | 4 | 13.25% |
2 | Associative Containers (set, multiset, map, multimap) | 4 | 13.25% |
3 | Algorithms: Non-Modifying Sequence Operations (find, count, search, equal) | 4 | 13.25% |
4 | Algorithms: Modifying Sequence Operations (copy, fill, transform, replace, remove, reverse, rotate) | 4 | 13.25% |
5 | Algorithms: Sorting and Binary Search (sort, stable_sort, lower_bound, upper_bound, binary_search) | 5 | 16.5% |
6 | Algorithms: Merge, Set Operations, Min/Max (merge, set_union, set_intersection, min_element, max_element) | 5 | 16.5% |
7 | STL Functional Objects and Utilities (plus, minus, ptr_fun, function adapters) | 2 | 7% |
8 | Advanced I/O (stream manipulators, setf/unsetf, setprecision, setw) | 2 | 7% |
9 | Templates (function templates, class templates, specialization, nested templates) | 2 | 7% |
Blocks 5 and 6 — sorting, binary search, merging, and set operations — carry the most combined weight at roughly a third of the exam between them. If your STL practice has leaned toward containers and basic algorithms, this is where you likely have the biggest gap to close.
The distinction between std::find family functions. Candidates know std::find but blank on when std::find_if, std::find_end, std::find_first_of, and std::adjacent_find apply — and the exam tests the distinctions directly, not just whether you’ve heard of each one.
Set operations on sorted ranges. std::set_union, std::set_intersection, std::set_difference, and std::set_symmetric_difference require their input ranges to already be sorted, and questions frequently hinge on exactly that precondition — not the mechanics of the call itself.
Iterator invalidation after modifying algorithms. std::remove doesn’t actually shrink a container — it moves elements and returns a new logical end, which candidates who’ve only used containers casually tend to get wrong when a question asks what the container looks like after the call.
Template specialization syntax. Block 9 is only 7% of the exam, but it’s conceptually the densest block per question — partial and full specialization, and nested templates inside other template classes, show up in a small number of items that are disproportionately easy to miss if you haven’t written this syntax yourself.
Don’t just memorize what each STL function does — write and run the code. CPP-22-02 questions are built around actual function signatures and return values, and the fastest way to internalize std::lower_bound versus std::upper_bound, or what std::unique actually returns, is to compile small examples and watch the output rather than read a definition.
Given the exam’s tight 65-minute window for 40 questions — under two minutes each — time yourself on practice sets from the start. Candidates who know the material but haven’t practiced under time pressure often run out of time on the sorting and merging blocks, where questions tend to involve more code to read.
Treating CPA-level container knowledge as sufficient — CPP assumes you already know basic container operations and tests the advanced algorithm layer on top of them.
Skipping templates and advanced I/O because they’re each only 7% individually — together with functional objects, that’s 21% of the exam, more than two full blocks’ worth.
Confusing std::sort and std::stable_sort behavior with equal elements, a distinction the exam tests directly.
Not practicing with user-defined (custom class) types in containers and algorithms — the syllabus explicitly calls out using containers “with both simple and complex (user-defined) data types,” and questions test this, not just built-in types like int or string.
Beginner (comfortable with basic C++ syntax but limited STL exposure): C++ Institute recommends holding CPA first, and for good reason — budget 6–8 weeks working through STL containers and algorithms systematically before attempting CPP-level material.
Has related experience (already uses STL containers and algorithms regularly in code): 2–3 weeks, concentrated on the specific function families you don’t use day-to-day — set operations and functional objects are common gaps even for working C++ developers, since most day-to-day code leans on a narrow subset of the STL.
Retaking: C++ Institute requires a 15-day wait after a failed attempt. Use that window to go block by block through your weak areas rather than re-reviewing everything — given the exam’s narrow time budget, precision on the blocks you missed matters more than broad re-reading.
The active version is CPP-22-02, last updated July 22, 2025, with the certification originally dating back to 2013. C++ Institute revises exam versions periodically as the C++ standard evolves and STL usage patterns shift, so if you’re studying from material referencing an older version code, confirm it matches CPP-22-02 specifically — earlier versions have had different block structures and weightings.
Last updated on Oct, 22 2026