Execution Policies for STL Algorithms
1. In which version was the execution policies first added in C++ ISO Standard?
STL Algorithms execution policies were first introduced in C++17 Standard and then C++20 also added one more type later on.
2. List the STL Algorithms that support execution policies.
Here is the full list of C++ algorithms that support execution policies:
| std:: adjacent_difference | std:: adjacent_find | std::all_of | std::any_of |
| std:: copy | std:: copy_if | std:: copy_n | std:: count |
| std:: count_if | std:: equal | std:: fill | std:: fill_n |
| std:: find | std:: find_end | std:: find_first_of | std :: find if |
| std:: find_if_not | std:: generate | std:: generate_n | std:: includes |
| std:: inner_product | std:: inplace_merge | std:: is_heap | std:: is_heap_until |
| std:: is_partitioned | std: is_sorted | std:: is_sorted_until | |
| std :: max element | std:: merge | std:: min_element | std :: minmax_element |
| std:: mismatch | std move | std:: none_of | std:: nth_element |
| std:: partial_sort | std partial_sort_copy | std: partition | std:: partition_copy |
| std: remove | std:: remove_copy | std: remove_copy_if | std:: remove_if |
| std:: replace | std:: replace_copy | std: replace_copy_if | std:: replace_if |
| std: reverse | std:: reverse_copy | std:: rotate | std:: rotate_copy |
| std:: search | std:: search_n | std:: set_difference | std:: set_intersection |
| std:: set_symmetric_difference | std:: set_union | std:: sort | std: stable_partition |
| std:: stable_sort | std:: swap_ranges | std:: transform | std:: uninitialized_copy |
| std: uninitialized_copy_n | std:: uninitialized_fill | std:: uninitialized_fill_n | std:: unique |
| std:: unique_copy |
Keep in mind that the availability of these policies may vary depending on the implementation and the version of the C++ standard used.
Execution Policy of STL Algorithms in Modern C++
C++ algorithms are a set of pre-defined functions that can perform various operations on containers, such as arrays, vectors, and lists. These algorithms have a defined execution policy that determines how they execute and how they interact with the underlying hardware.
The C++ 17 standard introduces three new execution policies and one policy was introduced in C++20. These execution policies in C++ allow algorithms to be executed in different ways depending on the requirements of the task and the hardware available. They are as follows:
- std::execution::sequenced_policy
- std::execution::parallel_policy
- std::execution::parallel_unsequenced_policy
- std::execution::unsequenced_policy
Contact Us