CPP – C++ Certified Professional Programmer Certification

---

CPP – C++ Certified Professional Programmer is an advanced-level certification that validates your ability to accomplish coding, design, and problem-solving tasks in modern C++. The certification focuses on the advanced use of C++ language features, the Standard Template Library (STL), advanced algorithms, memory management, and key programming patterns used in professional software development.

By earning the CPP certification, you demonstrate proficiency in using STL containers, algorithms, iterators, functional programming tools, smart pointers, templates, advanced I/O manipulation, and language features introduced in modern C++. The certification also confirms your readiness to work with complex data structures, generic programming, and efficient resource management — skills highly valued in the software industry.

Exam Information

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

---

CPP Exam Syllabus

---

Exam Overview

The CPP certification exam assesses a candidate’s ability to design, implement, and optimize advanced C++ programs using the Standard Template Library (STL), algorithms, and modern language features. The exam focuses on practical programming skills, efficient use of data structures, algorithm application, memory management, I/O stream manipulation, and generic programming with templates.

The CPP exam consists of 40 questions (items), each contributing one point toward the total score. Candidates can earn a maximum of 40 points, with their total score converted into a percentage. To pass the exam, a candidate must achieve a cumulative score of 70% or higher based on the total points earned across all questions — the result is not calculated as a simple average of scores per exam block.

Exam Objectives by Block

Block 1 – Sequence Containers and Container Adapters
(Exam items: 4 | Weight: 13.25%)

1. 1.1 Identify and explain the purpose and characteristics of sequence containers: std::vector, std::deque, std::list.
2. 1.2 Identify and explain the purpose and characteristics of container adapters: std::queue, std::priority_queue, std::stack.
3. 1.3 Apply standard methods of vector, deque, list, queue, priority_queue, and stack for common operations (e.g., insertion, deletion, access).
4. 1.4 Use iterators to traverse and access elements in sequence containers and adapters.
5. 1.5 Manipulate sequence containers with both simple (built-in) and complex (user-defined) data types.
6. 1.6 Access and modify container elements using member functions and iterator-based approaches.

Scope & Keywords: std::vector, std::deque, std::list, std::queue, std::priority_queue, std::stack, container adapters, iterators, element access, insertion and removal methods, use with user-defined types.

Block 2 – Associative Containers
(Exam items: 4 | Weight: 13.25%)

1. 2.1 Identify and explain the characteristics and use cases of associative containers: std::set, std::multiset, std::map, std::multimap.
2. 2.2 Apply standard methods of set, multiset, map, and multimap for insertion, deletion, search, and data retrieval.
3. 2.3 Use associative containers with both simple (built-in) and complex (user-defined) data types.
4. 2.4 Traverse associative containers using iterators and access stored data.
5. 2.5 Perform operations on container elements using container-specific member functions and iterators.

Scope & Keywords: std::set, std::multiset, std::map, std::multimap, insertion, deletion, search, iterators, key-value pairs, use with user-defined types.

Block 3 – Algorithms: Non-Modifying Sequence Operations
(Exam items: 4 | Weight: 13.25%)

1. 3.1 Explain the purpose of non-modifying sequence algorithms and their use cases in iterating over containers.
2. 3.2 Apply std::for_each to iterate over a range of elements and perform an operation on each element.
3. 3.3 Use searching algorithms such as std::find, std::find_if, std::find_end, std::find_first_of, std::adjacent_find, std::search, and std::search_n to locate elements within containers.
4. 3.4 Apply counting algorithms std::count and std::count_if to count elements based on specified criteria.
5. 3.5 Use comparison algorithms std::mismatch and std::equal to compare ranges of elements in containers.

Scope & Keywords: std::for_each, std::find, std::find_if, std::find_end, std::find_first_of, std::adjacent_find, std::search, std::search_n, std::count, std::count_if, std::mismatch, std::equal, iteration, searching, comparing ranges.

Block 4 – Algorithms: Modifying Sequence Operations
(Exam items: 4 | Weight: 13.25%)

1. 4.1 Apply algorithms for generating and copying data, including std::copy, std::copy_backward, std::fill, std::fill_n, std::generate, and std::generate_n.
2. 4.2 Use swapping and transformation algorithms such as std::swap_ranges, std::swap, std::iter_swap, and std::transform to manipulate container elements.
3. 4.3 Apply replacement and removal algorithms, including std::replace, std::remove, std::remove_if, std::unique, and std::unique_copy, to modify container contents.
4. 4.4 Use sequence-reordering algorithms such as std::reverse, std::reverse_copy, std::rotate, std::partition, and std::stable_partition for rearranging elements in containers.

Scope & Keywords: std::copy, std::fill, std::generate, std::swap, std::transform, std::replace, std::remove, std::unique, std::reverse, std::rotate, std::partition, modifying container elements, removing duplicates, rearranging sequences.

Block 5 – Algorithms: Sorting and Binary Search
(Exam items: 5 | Weight: 16.5%)

1. 5.1 Apply sorting algorithms std::sort and std::stable_sort to arrange elements in ordered sequences based on default or custom comparison criteria.
2. 5.2 Use binary search algorithms, including std::lower_bound, std::upper_bound, and std::binary_search, to search for elements in sorted containers efficiently.

Scope & Keywords: std::sort, std::stable_sort, std::lower_bound, std::upper_bound, std::binary_search, sorting algorithms, binary search, sorted containers, custom comparison functions.

Block 6 – Algorithms: Merge, Heap, Min, Max
(Exam items: 5 | Weight: 16.5%)

1. 6.1 Apply merging algorithms such as std::merge and std::inplace_merge to combine sorted sequences into a single sorted sequence.
2. 6.2 Use set operations on sorted sequences, including std::includes, std::set_union, std::set_intersection, std::set_difference, and std::set_symmetric_difference.
3. 6.3 Apply algorithms for finding minimum and maximum elements in a range, including std::min_element and std::max_element.

Scope & Keywords: std::merge, std::inplace_merge, std::includes, std::set_union, std::set_intersection, std::set_difference, std::set_symmetric_difference, std::min_element, std::max_element, merging sorted sequences, set operations, min/max search.

Block 7 – STL Functional Objects and Utilities
(Exam items: 2 | Weight: 7%)

1. 7.1 Apply STL functional objects such as std::plus, std::minus, and other standard function objects with algorithms like std::transform.
2. 7.2 Use std::ptr_fun and other function adapters to bind functions for use with algorithms.

Scope & Keywords: std::plus, std::minus, std::transform, std::ptr_fun, functional objects, function adapters, algorithm utilities.

Block 8 – Advanced I/O
(Exam items: 2 | Weight: 7%)

1. 8.1 Apply advanced input/output operations using stream objects such as std::cout, std::cin, and std::cerr.
2. 8.2 Use stream format flags with setf and unsetf methods to control I/O behavior and appearance.
3. 8.3 Apply stream manipulators such as boolalpha, noshowpoint, setprecision, fixed, and setw to format output.

Scope & Keywords: std::cout, std::cin, setf, unsetf, boolalpha, noshowpoint, setprecision, fixed, setw, stream manipulators, formatting output.

Block 9 – Templates
(Exam items: 2 | Weight: 7%)

1. 9.1 Define template functions and specialized template functions for generic programming.
2. 9.2 Define template classes and instantiate them with various data types.
3. 9.3 Use functions and operator functions from other classes with template classes.
4. 9.4 Declare and use template classes inside other template classes (nested templates).

Scope & Keywords: template functions, function templates, class templates, template specialization, nested templates, operator overloading with templates.

MQC Profile

A Minimally Qualified Candidate (MQC) for the CPP – C++ Certified Professional Programmer certification demonstrates advanced programming proficiency in C++ and a strong command of the Standard Template Library (STL). The MQC can effectively select and apply STL containers, iterators, and algorithms to solve complex programming problems.

The candidate possesses the ability to use advanced STL algorithms for searching, sorting, merging, and set operations, and can apply functional programming utilities, advanced I/O formatting techniques, and generic programming patterns with templates. They are skilled in working with both built-in and user-defined data types, understand the proper use of iterators and function objects, and can write efficient, reusable, and maintainable code in C++.

The MQC is prepared to work on real-world software projects that require deep knowledge of modern C++ practices, resource management, and algorithmic thinking, and is ready to pursue advanced professional roles in software development.

Last updated: July 22, 2025
First published: September 10, 2013
Aligned with CPP-22-02