diff --git a/reference/algorithm/ranges_adjacent_find.md b/reference/algorithm/ranges_adjacent_find.md index e9b81315ad..72ce400c5b 100644 --- a/reference/algorithm/ranges_adjacent_find.md +++ b/reference/algorithm/ranges_adjacent_find.md @@ -20,9 +20,36 @@ namespace std::ranges { projected, Proj>> Pred = ranges::equal_to> constexpr borrowed_iterator_t adjacent_find(R&& r, Pred pred = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_binary_predicate, + projected> Pred = ranges::equal_to> + I adjacent_find(Ep&& exec, + I first, + S last, + Pred pred = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>, + projected, Proj>> Pred = ranges::equal_to> + borrowed_iterator_t + adjacent_find(Ep&& exec, + R&& r, + Pred pred = {}, + Proj proj = {}); // (4) C++26 } ``` * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -30,6 +57,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する このアルゴリズムは、範囲の先頭から1つづつ進みながら隣接するペアに対して条件を満たすかをチェックし、その条件を満たす最初の要素へのイテレータを返す。指定された条件を満たしているかをチェックされるのは、現在位置にある要素とその次の位置にある要素の2つについてであり、1つの要素は最大2回参照される。 @@ -61,6 +90,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -83,13 +113,13 @@ int main() { * std::ranges::distance[link /reference/iterator/ranges_distance.md] * std::ranges::adjacent_find[color ff0000] -### 出力 +#### 出力 ``` found: index==2 *it == *(it+1): true ``` -### 動作イメージ +#### 動作イメージ ``` |0 1 2 3 4 5 6| : index @@ -102,6 +132,32 @@ found: index==2 [2, 2] ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 4, 3, 3, 1, 2, 2}; + + // 並列に同じ値が連続している最初の要素を検索する + auto it = std::ranges::adjacent_find(std::execution::par, v); + if (it == v.end()) { + std::cout << "not found" << std::endl; + } else { + std::cout << "found: index==" << std::distance(v.begin(), it) << std::endl; + } +} +``` +* std::ranges::adjacent_find[color ff0000] + +#### 出力 +``` +found: index==2 +``` + ## 実装例 ```cpp struct adjacent_find_impl { @@ -144,3 +200,4 @@ inline constexpr adjacent_find_impl adjacent_find; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_all_of.md b/reference/algorithm/ranges_all_of.md index 861c19bff4..d04dd5edf5 100644 --- a/reference/algorithm/ranges_all_of.md +++ b/reference/algorithm/ranges_all_of.md @@ -18,14 +18,40 @@ namespace std::ranges { indirect_unary_predicate, Proj>> Pred> constexpr bool all_of(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + bool all_of(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + bool all_of(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の全ての要素が条件を満たすかを判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 - (1): @@ -43,6 +69,7 @@ namespace std::ranges { 最大で `last - first` 回 `proj` と `pred` を実行する。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -64,12 +91,37 @@ int main() { ``` * std::ranges::all_of[color ff0000] -### 出力 +#### 出力 ``` true false ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {2, 4, 6, 8, 10}; + + std::cout << std::boolalpha; + + // 並列に全ての要素が偶数であるかを判定 + bool result = std::ranges::all_of(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + std::cout << result << std::endl; +} +``` +* std::ranges::all_of[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp struct all_of_impl { @@ -111,3 +163,4 @@ inline constexpr all_of_impl all_of; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_any_of.md b/reference/algorithm/ranges_any_of.md index 25e3f53fb7..4802baf5cc 100644 --- a/reference/algorithm/ranges_any_of.md +++ b/reference/algorithm/ranges_any_of.md @@ -18,14 +18,40 @@ namespace std::ranges { indirect_unary_predicate, Proj>> Pred> constexpr bool any_of(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + bool any_of(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + bool any_of(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲のいずれかの要素が条件を満たすかを判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 - (1): @@ -45,6 +71,7 @@ namespace std::ranges { 最大で `last - first` 回 `pred` を実行する。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -66,12 +93,37 @@ int main() { ``` * std::ranges::any_of[color ff0000] -### 出力 +#### 出力 ``` false true ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 3, 5, 7, 8}; + + std::cout << std::boolalpha; + + // 並列にいずれかの要素が偶数であるかを判定 + bool result = std::ranges::any_of(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + std::cout << result << std::endl; +} +``` +* std::ranges::any_of[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp struct any_of_impl { @@ -114,3 +166,4 @@ inline constexpr any_of_impl any_of; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_contains.md b/reference/algorithm/ranges_contains.md index 7610047983..ec958c6c13 100644 --- a/reference/algorithm/ranges_contains.md +++ b/reference/algorithm/ranges_contains.md @@ -59,14 +59,52 @@ namespace std::ranges { contains(R&& r, const T& value, Proj proj = {}); // (2) C++26 + + template S, + class Proj = identity, + class T = projected_value_t> + requires indirect_binary_predicate< + ranges::equal_to, + projected, + const T* + > + bool + contains(Ep&& exec, + I first, + S last, + const T& value, + Proj proj = {}); // (3) C++26 + + template , Proj>> + requires indirect_binary_predicate< + ranges::equal_to, + projected, Proj>, + const T* + > + bool + contains(Ep&& exec, + R&& r, + const T& value, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値が含まれるか調べる。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -148,6 +186,30 @@ found ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {3, 1, 4, 1, 5}; + + std::cout << std::boolalpha; + + // 並列に値が含まれるかを判定 + bool result = std::ranges::contains(std::execution::par, v, 4); + std::cout << result << std::endl; +} +``` +* std::ranges::contains[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp struct contains_impl { @@ -182,3 +244,4 @@ inline constexpr contains_impl contains; - [N4950 27 Algorithms library](https://timsong-cpp.github.io/cppwp/n4950/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_contains_subrange.md b/reference/algorithm/ranges_contains_subrange.md index 9be4d01fe9..55bbe2a5b9 100644 --- a/reference/algorithm/ranges_contains_subrange.md +++ b/reference/algorithm/ranges_contains_subrange.md @@ -6,7 +6,7 @@ ```cpp namespace std::ranges { - // (1) + // (1) C++23 template S1, forward_iterator I2, sentinel_for S2, class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> @@ -14,20 +14,43 @@ namespace std::ranges { constexpr bool ranges::contains_subrange(I1 first1, S1 last1, I2 first2, S2 last2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); - // (2) + // (2) C++23 template requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> constexpr bool ranges::contains_subrange(R1&& r1, R2&& r2, Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); + + // (3) C++26 + template S1, + random_access_iterator I2, sized_sentinel_for S2, + class Pred = ranges::equal_to, class Proj1 = identity, class Proj2 = identity> + requires indirectly_comparable + bool ranges::contains_subrange(Ep&& exec, I1 first1, S1 last1, I2 first2, S2 last2, + Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); + + // (4) C++26 + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + bool ranges::contains_subrange(Ep&& exec, R1&& r1, R2&& r2, Pred pred = {}, + Proj1 proj1 = {}, Proj2 proj2 = {}); } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 あるシーケンスの中に、特定のサブシーケンスが含まれるか調べる。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する サブシーケンスが空の場合は、常に`true`を返す。 @@ -40,6 +63,7 @@ first2 == last2 || !ranges::search(first1, last1, first2, last2, pred, proj1, pr 最大で `(last1 - first1) * (last2 - first2)` 回の、対応する比較もしくは述語が適用される ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -64,6 +88,32 @@ int main() { found ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5}; + std::vector sub = {2, 3, 4}; + + std::cout << std::boolalpha; + + // 並列にサブ範囲が含まれるかを判定 + bool result = std::ranges::contains_subrange( + std::execution::par, v, sub); + std::cout << result << std::endl; +} +``` +* std::ranges::contains_subrange[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp @@ -101,3 +151,4 @@ inline constexpr contains_subrange_impl contains_subrange; ## 参照 - [N4950 27 Algorithms library](https://timsong-cpp.github.io/cppwp/n4950/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_copy.md b/reference/algorithm/ranges_copy.md index 7e13c6f733..d2579c96f4 100644 --- a/reference/algorithm/ranges_copy.md +++ b/reference/algorithm/ranges_copy.md @@ -18,18 +18,46 @@ namespace std::ranges { requires indirectly_copyable, O> constexpr copy_result, O> copy(R&& r, O result); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS> + requires indirectly_copyable + copy_result + copy(Ep&& exec, + I first, + S last, + O result, + OutS result_last); // (3) C++26 + + template + requires indirectly_copyable, iterator_t> + copy_result, borrowed_iterator_t> + copy(Ep&& exec, + R&& r, + OutR&& result_r); // (4) C++26 } ``` * copy_result[link ranges_in_out_result.md] * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された範囲の要素をコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -57,6 +85,7 @@ copy_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -83,11 +112,38 @@ int main() { ``` * std::ranges::copy[color ff0000] -### 出力 +#### 出力 ``` 3,1,2, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5}; + std::vector dst(src.size()); + + // 並列にコピーする + std::ranges::copy(std::execution::par, src, dst); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::copy[color ff0000] + +#### 出力 +``` +1 2 3 4 5 +``` + ## バージョン ### 言語 - C++20 @@ -100,3 +156,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_copy_if.md b/reference/algorithm/ranges_copy_if.md index 978a8b995d..faf63d7368 100644 --- a/reference/algorithm/ranges_copy_if.md +++ b/reference/algorithm/ranges_copy_if.md @@ -22,18 +22,54 @@ namespace std::ranges { requires indirectly_copyable, O> constexpr copy_if_result, O> copy_if(R&& r, O result, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS, + class Proj = identity, + indirect_unary_predicate> Pred> + requires indirectly_copyable + copy_if_result + copy_if(Ep&& exec, + I first, + S last, + O result, + OutS result_last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires indirectly_copyable, iterator_t> + copy_if_result, borrowed_iterator_t> + copy_if(Ep&& exec, + R&& r, + OutR&& result_r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * copy_if_result[link ranges_in_out_result.md] * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 条件を満たす要素のみをコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -60,6 +96,7 @@ copy_if_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -91,6 +128,34 @@ int main() { 3,1,1,5,9,5, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + std::vector dst(src.size()); + + // 並列に偶数のみをコピーする + auto result = std::ranges::copy_if(std::execution::par, src, dst, + [](int x) { return x % 2 == 0; }); + + for (auto it = dst.begin(); it != result.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::copy_if[color ff0000] + +#### 出力 +``` +2 4 6 8 10 +``` + ## バージョン ### 言語 - C++20 @@ -103,3 +168,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_copy_n.md b/reference/algorithm/ranges_copy_n.md index 34cb49ca28..2bb46e2877 100644 --- a/reference/algorithm/ranges_copy_n.md +++ b/reference/algorithm/ranges_copy_n.md @@ -13,17 +13,33 @@ namespace std::ranges { constexpr copy_n_result copy_n(I first, iter_difference_t n, - O result); // (1) C++20 + O result); // (1) C++20 + + template OutS> + requires indirectly_copyable + copy_n_result + copy_n(Ep&& exec, + I first, + iter_difference_t n, + O result, + OutS result_last); // (2) C++26 } ``` * copy_n_result[link ranges_in_out_result.md] * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] ## 概要 指定された数の要素をコピーする。 - (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する ## 効果 @@ -45,6 +61,7 @@ copy_n_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -67,6 +84,34 @@ int main() { 4 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5}; + std::vector dst(5); + + // 並列に先頭3要素をコピー + std::ranges::copy_n(std::execution::par, src.begin(), 3, + dst.begin(), dst.begin() + 3); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::copy_n[color ff0000] + +#### 出力 +``` +1 2 3 0 0 +``` + ## バージョン ### 言語 - C++20 @@ -79,3 +124,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_count.md b/reference/algorithm/ranges_count.md index 58a13d5e8e..05e78aae0e 100644 --- a/reference/algorithm/ranges_count.md +++ b/reference/algorithm/ranges_count.md @@ -43,14 +43,44 @@ namespace std::ranges { count(R&& r, const T& value, Proj proj = {}); // (2) C++26 + + template S, + class Proj = identity, + class T = projected_value_t> + requires indirect_binary_predicate, const T*> + iter_difference_t + count(Ep&& exec, + I first, + S last, + const T& value, + Proj proj = {}); // (3) C++26 + + template , Proj>> + requires indirect_binary_predicate, Proj>, const T*> + range_difference_t + count(Ep&& exec, + R&& r, + const T& value, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値と等値な要素の数を数える。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 - (1): @@ -170,6 +200,28 @@ count of id==1: 1 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 4, 3, 3, 1, 2, 2, 1}; + + // 並列に値が 1 の要素がいくつあるかを数える + auto n = std::ranges::count(std::execution::par, v, 1); + std::cout << "count of 1: " << n << std::endl; +} +``` +* std::ranges::count[color ff0000] + +#### 出力 +``` +count of 1: 3 +``` + ## 実装例 ```cpp struct count_impl { @@ -210,3 +262,4 @@ inline constexpr count_impl count; - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_count_if.md b/reference/algorithm/ranges_count_if.md index 265ff9c5ae..3aa760e14f 100644 --- a/reference/algorithm/ranges_count_if.md +++ b/reference/algorithm/ranges_count_if.md @@ -18,8 +18,34 @@ namespace std::ranges { indirect_unary_predicate, Proj>> Pred> constexpr range_difference_t count_if(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + iter_difference_t + count_if(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + range_difference_t + count_if(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -27,6 +53,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 - (1): @@ -47,6 +75,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -62,12 +91,35 @@ int main() { ``` * std::ranges::count_if[color ff0000] -### 出力 +#### 出力 ```cpp count of 1 or 3: 5 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 4, 3, 3, 1, 2, 2, 1}; + + // 並列に値が偶数の要素がいくつあるかを数える + auto n = std::ranges::count_if(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + std::cout << "count of even: " << n << std::endl; +} +``` +* std::ranges::count_if[color ff0000] + +#### 出力 +``` +count of even: 3 +``` + ## 実装例 ```cpp struct count_if_impl { @@ -104,3 +156,4 @@ inline constexpr count_if_impl count_if; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_ends_with.md b/reference/algorithm/ranges_ends_with.md index 4b15e622c6..a5e321787a 100644 --- a/reference/algorithm/ranges_ends_with.md +++ b/reference/algorithm/ranges_ends_with.md @@ -39,9 +39,46 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++23 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + bool + ends_with(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + bool + ends_with(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -49,6 +86,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -66,6 +105,7 @@ namespace std::ranges { 最大で `N2` 回の対応する述語が適用される。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -83,7 +123,7 @@ int main() { ``` * std::ranges::ends_with[color ff0000] -### 出力 +#### 出力 ``` 0 0 @@ -91,6 +131,31 @@ int main() { ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5, 6}; + std::vector suffix = {4, 5, 6}; + + std::cout << std::boolalpha; + + // 並列に末尾が一致するかを判定 + bool result = std::ranges::ends_with(std::execution::par, v, suffix); + std::cout << result << std::endl; +} +``` +* std::ranges::ends_with[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp struct ends_with_impl { @@ -138,3 +203,4 @@ inline constexpr ends_with_impl ends_with; ## 参照 - [N4950 27 Algorithms library](https://timsong-cpp.github.io/cppwp/n4950/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_equal.md b/reference/algorithm/ranges_equal.md index d3a0c6d147..2493dbde18 100644 --- a/reference/algorithm/ranges_equal.md +++ b/reference/algorithm/ranges_equal.md @@ -35,14 +35,52 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + bool equal(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + bool equal(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つの範囲を等値比較する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する 2つの範囲の要素数および各要素が等値であった場合、`true`を返す。 @@ -57,6 +95,7 @@ namespace std::ranges { 最大で `min(last1 - first1, last2 - first2)` 回の述語が適用される。ただし、2つの範囲の長さを定数時間で求められ、かつ、長さが異なる場合、1 度も述語は適用されない。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -79,13 +118,38 @@ int main() { ``` * std::ranges::equal[color ff0000] -### 出力 +#### 出力 ``` false true ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v1 = {1, 2, 3, 4, 5}; + std::vector v2 = {1, 2, 3, 4, 5}; + + std::cout << std::boolalpha; + + // 並列に2つの範囲が等しいかを判定 + bool result = std::ranges::equal(std::execution::par, v1, v2); + std::cout << result << std::endl; +} +``` +* std::ranges::equal[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp @@ -130,3 +194,4 @@ inline constexpr equal_impl equal; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_fill.md b/reference/algorithm/ranges_fill.md index 2c2985e6b0..3987beacde 100644 --- a/reference/algorithm/ranges_fill.md +++ b/reference/algorithm/ranges_fill.md @@ -10,32 +10,58 @@ namespace std::ranges { output_iterator O, sentinel_for S> constexpr O - fill(O first, S last, const T& value); // (1) C++20 + fill(O first, S last, const T& value); // (1) C++20 template S, class T = iter_value_t> requires output_iterator constexpr O - fill(O first, S last, const T& value); // (1) C++26 + fill(O first, S last, const T& value); // (1) C++26 template R> constexpr borrowed_iterator_t - fill(R&& r, const T& value); // (2) C++20 + fill(R&& r, const T& value); // (2) C++20 template > requires output_range constexpr borrowed_iterator_t - fill(R&& r, const T& value); // (2) C++26 + fill(R&& r, const T& value); // (2) C++26 + + template S, + class T> + requires indirectly_writable + O fill(Ep&& exec, + O first, + S last, + const T& value); // (3) C++26 + + template + requires indirectly_writable, const T&> + borrowed_iterator_t + fill(Ep&& exec, + R&& r, + const T& value); // (4) C++26 } ``` * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* indirectly_writable[link /reference/iterator/indirectly_writable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値で出力の範囲に書き込む。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -118,6 +144,32 @@ int main() { 1,2 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v(10); + + // 並列に全要素を42で埋める + std::ranges::fill(std::execution::par, v, 42); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::fill[color ff0000] + +#### 出力 +``` +42 42 42 42 42 42 42 42 42 42 +``` + ## バージョン ### 言語 - C++20 @@ -132,3 +184,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_fill_n.md b/reference/algorithm/ranges_fill_n.md index dfca5a816f..64bfa0c80e 100644 --- a/reference/algorithm/ranges_fill_n.md +++ b/reference/algorithm/ranges_fill_n.md @@ -11,20 +11,35 @@ namespace std::ranges { constexpr O fill_n(O first, iter_difference_t n, - const T& value); // (1) C++20 + const T& value); // (1) C++20 template > requires output_iterator constexpr O fill_n(O first, iter_difference_t n, - const T& value); // (1) C++26 + const T& value); // (1) C++26 + + template + requires indirectly_writable + O fill_n(Ep&& exec, + O first, + iter_difference_t n, + const T& value); // (2) C++26 } ``` +* indirectly_writable[link /reference/iterator/indirectly_writable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 指定された値で出力の範囲に `n` 個を書き込む。 +- (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する + ## 効果 `n` が 1 以上の場合は `[first,first + n)` 内の全ての要素に `value` を代入し、そうでない場合は何もしない。 @@ -102,6 +117,32 @@ int main() { ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v(5); + + // 並列に先頭3要素を42で埋める + std::ranges::fill_n(std::execution::par, v.begin(), 3, 42); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::fill_n[color ff0000] + +#### 出力 +``` +42 42 42 0 0 +``` + ## バージョン ### 言語 - C++20 @@ -116,3 +157,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find.md b/reference/algorithm/ranges_find.md index 8823240a02..67daa20d7f 100644 --- a/reference/algorithm/ranges_find.md +++ b/reference/algorithm/ranges_find.md @@ -43,15 +43,44 @@ namespace std::ranges { find(R&& r, const T& value, Proj proj = {}); // (2) C++26 + + template S, + class Proj = identity, + class T = projected_value_t> + requires indirect_binary_predicate, const T*> + I find(Ep&& exec, + I first, + S last, + const T& value, + Proj proj = {}); // (3) C++26 + + template , Proj>> + requires indirect_binary_predicate, Proj>, const T*> + borrowed_iterator_t + find(Ep&& exec, + R&& r, + const T& value, + Proj proj = {}); // (4) C++26 } ``` * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値を検索する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -186,6 +215,29 @@ int main() { found: 3,4 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に値を検索する + auto it = std::ranges::find(std::execution::par, v, 5); + if (it != v.end()) { + std::cout << "found: " << *it << std::endl; + } +} +``` +* std::ranges::find[color ff0000] + +#### 出力 +``` +found: 5 +``` ## 実装例 ```cpp @@ -226,3 +278,4 @@ inline constexpr find_impl find; - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_end.md b/reference/algorithm/ranges_find_end.md index 6369dfd7ef..8d6310f309 100644 --- a/reference/algorithm/ranges_find_end.md +++ b/reference/algorithm/ranges_find_end.md @@ -35,14 +35,54 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + subrange + find_end(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + borrowed_subrange_t + find_end(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の中から、特定のサブシーケンスを検索する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -61,6 +101,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -85,12 +126,39 @@ int main() { ``` * std::ranges::find_end[color ff0000] -### 出力 +#### 出力 ``` found: index==2 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 1, 2, 3}; + std::vector pattern = {1, 2}; + + // 並列にサブシーケンスを末尾から検索する + auto sr = std::ranges::find_end(std::execution::par, v, pattern); + if (sr.empty()) { + std::cout << "not found" << std::endl; + } else { + std::cout << "found: index==" << std::distance(v.begin(), sr.begin()) << std::endl; + } +} +``` +* std::ranges::find_end[color ff0000] + +#### 出力 +``` +found: index==2 +``` + ## 実装例 ```cpp struct find_end_impl { @@ -130,3 +198,4 @@ inline constexpr find_end_impl find_end; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_first_of.md b/reference/algorithm/ranges_find_first_of.md index a4beb961ab..db300c21bf 100644 --- a/reference/algorithm/ranges_find_first_of.md +++ b/reference/algorithm/ranges_find_first_of.md @@ -35,15 +35,55 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + I1 + find_first_of(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + borrowed_iterator_t + find_first_of(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 ある集合の1つとマッチする最初の要素を検索する。 -* (1): イテレータ範囲を指定する -* (2): Rangeを直接指定する +- (1): イテレータ範囲を指定する +- (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -57,6 +97,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -78,12 +119,40 @@ int main() { ``` * std::ranges::find_first_of[color ff0000] -### 出力 +#### 出力 ``` found: index==3, value==4 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 3, 7, 4, 2}; + std::vector targets = {2, 4, 6, 8}; + + // 並列に targets のいずれかと一致する最初の要素を検索する + auto it = std::ranges::find_first_of(std::execution::par, v, targets); + if (it == v.end()) { + std::cout << "not found" << std::endl; + } else { + std::cout << "found: index==" << std::distance(v.begin(), it) + << ", value==" << *it << std::endl; + } +} +``` +* std::ranges::find_first_of[color ff0000] + +#### 出力 +``` +found: index==3, value==4 +``` + ## 実装例 ```cpp struct find_first_of_impl { @@ -124,3 +193,4 @@ inline constexpr find_first_of_impl find_first_of; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_if.md b/reference/algorithm/ranges_find_if.md index e6cf396a7a..bd5d39c343 100644 --- a/reference/algorithm/ranges_find_if.md +++ b/reference/algorithm/ranges_find_if.md @@ -23,15 +23,42 @@ namespace std::ranges { find_if(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + I find_if(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + borrowed_iterator_t + find_if(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の中から、指定された条件を満たす最初の要素を検索する。 -* (1): イテレータ範囲を指定する -* (2): Rangeを直接指定する +- (1): イテレータ範囲を指定する +- (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -43,6 +70,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -61,12 +89,39 @@ int main() { ``` * std::ranges::find_if[color ff0000] -### 出力 +#### 出力 ``` found: 1 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {3, 1, 4, 1, 5, 9}; + + // 並列に5以上の最初の要素を検索する + auto result = std::ranges::find_if(std::execution::par, v, + [](int x) { return x >= 5; }); + if (result == v.end()) { + std::cout << "not found" << std::endl; + } else { + std::cout << "found: " << *result << std::endl; + } +} +``` +* std::ranges::find_if[color ff0000] + +#### 出力 +``` +found: 5 +``` + ## 実装例 ```cpp struct find_if_impl { @@ -103,3 +158,4 @@ inline constexpr find_if_impl find_if; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_if_not.md b/reference/algorithm/ranges_find_if_not.md index 2506938225..edee510d5b 100644 --- a/reference/algorithm/ranges_find_if_not.md +++ b/reference/algorithm/ranges_find_if_not.md @@ -23,15 +23,42 @@ namespace std::ranges { find_if_not(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + I find_if_not(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + borrowed_iterator_t + find_if_not(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の中から、指定された条件を満たさない最初の要素を検索する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -43,6 +70,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -61,12 +89,39 @@ int main() { ``` * std::ranges::find_if_not[color ff0000] -### 出力 +#### 出力 ``` found: 1 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {2, 4, 5, 6, 8}; + + // 並列に偶数でない最初の要素を検索する + auto result = std::ranges::find_if_not(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + if (result == v.end()) { + std::cout << "not found" << std::endl; + } else { + std::cout << "found: " << *result << std::endl; + } +} +``` +* std::ranges::find_if_not[color ff0000] + +#### 出力 +``` +found: 5 +``` + ## 実装例 ```cpp struct find_if_not_impl { @@ -103,3 +158,4 @@ inline constexpr find_if_not_impl find_if_not; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_last.md b/reference/algorithm/ranges_find_last.md index 228a6d65f6..41a33158ca 100644 --- a/reference/algorithm/ranges_find_last.md +++ b/reference/algorithm/ranges_find_last.md @@ -59,14 +59,52 @@ namespace std::ranges { find_last(R&& r, const T& value, Proj proj = {}); // (2) C++26 + + template S, + class Proj = identity, + class T = projected_value_t> + requires indirect_binary_predicate< + ranges::equal_to, + projected, + const T* + > + ranges::subrange + find_last(Ep&& exec, + I first, + S last, + const T& value, + Proj proj = {}); // (3) C++26 + + template , Proj>> + requires indirect_binary_predicate< + ranges::equal_to, + projected, Proj>, + const T* + > + ranges::borrowed_subrange_t + find_last(Ep&& exec, + R&& r, + const T& value, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値を末尾から検索する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -153,6 +191,33 @@ found: 3,4 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 3, 5, 3, 7}; + + // 並列に最後の3を検索 + auto result = std::ranges::find_last(std::execution::par, v, 3); + + if (!result.empty()) { + std::cout << "found: " << *result.begin() << std::endl; + std::cout << "position: " << (result.begin() - v.begin()) << std::endl; + } +} +``` +* std::ranges::find_last[color ff0000] + +#### 出力 +``` +found: 3 +position: 3 +``` + ## バージョン ### 言語 - C++23 @@ -169,3 +234,4 @@ found: 3,4 - C++26で波カッコ初期化 (リスト初期化) に対応した - 関連文書： - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_last_if.md b/reference/algorithm/ranges_find_last_if.md index 3364c92a82..83e9417b72 100644 --- a/reference/algorithm/ranges_find_last_if.md +++ b/reference/algorithm/ranges_find_last_if.md @@ -23,14 +23,42 @@ namespace std::ranges { find_last_if(R&& r, Pred pred, Proj proj = {}); // (2) C++23 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + ranges::subrange + find_last_if(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + ranges::borrowed_subrange_t + find_last_if(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の中から、指定された条件を満たす最後の要素を検索する。 -* (1): イテレータ範囲を指定する -* (2): Rangeを直接指定する +- (1): イテレータ範囲を指定する +- (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -42,6 +70,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -60,12 +89,40 @@ int main() { ``` * std::ranges::find_last_if[color ff0000] -### 出力 +#### 出力 ``` found: 1 pos: 3 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 4, 3, 6, 5}; + + // 並列に最後の偶数を検索 + auto result = std::ranges::find_last_if(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + + if (!result.empty()) { + std::cout << "found: " << *result.begin() << std::endl; + std::cout << "position: " << (result.begin() - v.begin()) << std::endl; + } +} +``` +* std::ranges::find_last_if[color ff0000] + +#### 出力 +``` +found: 6 +position: 3 +``` + ## バージョン ### 言語 - C++23 @@ -78,3 +135,4 @@ found: 1 ## 参照 - [P1223R5 find_last](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1223r5.pdf) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_find_last_if_not.md b/reference/algorithm/ranges_find_last_if_not.md index fbbc83a074..5d7e3e6891 100644 --- a/reference/algorithm/ranges_find_last_if_not.md +++ b/reference/algorithm/ranges_find_last_if_not.md @@ -23,14 +23,42 @@ namespace std::ranges { find_last_if_not(R&& r, Pred pred, Proj proj = {}); // (2) C++23 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + ranges::subrange + find_last_if_not(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + ranges::borrowed_subrange_t + find_last_if_not(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の中から、指定された条件を満たさない最後の要素を検索する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -42,6 +70,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -60,12 +89,40 @@ int main() { ``` * std::ranges::find_last_if_not[color ff0000] -### 出力 +#### 出力 ``` found: 1 pos: 3 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {2, 4, 3, 6, 8}; + + // 並列に最後の偶数でない要素を検索 + auto result = std::ranges::find_last_if_not(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + + if (!result.empty()) { + std::cout << "found: " << *result.begin() << std::endl; + std::cout << "position: " << (result.begin() - v.begin()) << std::endl; + } +} +``` +* std::ranges::find_last_if_not[color ff0000] + +#### 出力 +``` +found: 3 +position: 2 +``` + ## バージョン ### 言語 - C++23 @@ -78,3 +135,4 @@ found: 1 ## 参照 - [P1223R5 find_last](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1223r5.pdf) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_for_each.md b/reference/algorithm/ranges_for_each.md index 8638277ae9..8617440cf9 100644 --- a/reference/algorithm/ranges_for_each.md +++ b/reference/algorithm/ranges_for_each.md @@ -23,11 +23,36 @@ namespace std::ranges { for_each(R&& r, Fun f, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirectly_unary_invocable> Fun> + I for_each(Ep&& exec, + I first, + S last, + Fun f, + Proj proj = {}); // (3) C++26 + + template , Proj>> Fun> + borrowed_iterator_t + for_each(Ep&& exec, + R&& r, + Fun f, + Proj proj = {}); // (4) C++26 } ``` * indirectly_unary_invocable[link /reference/iterator/indirectly_unary_invocable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] * for_each_result[link /reference/algorithm/ranges_in_fun_result.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -35,6 +60,8 @@ namespace std::ranges { * (1): イテレータ範囲を指定する * (2): Rangeを直接指定する +* (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +* (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 - (1): @@ -54,14 +81,16 @@ namespace std::ranges { ## 戻り値 +- (1), (2): + ```cpp + for_each_result { + .in = last, + .fun = std::move(f), + } + ``` + * for_each_result[link /reference/algorithm/ranges_in_fun_result.md] -```cpp -for_each_result { - .in = last, - .fun = std::move(f), -} -``` -* for_each_result[link /reference/algorithm/ranges_in_fun_result.md] +- (3), (4): `last` ## 計算量 正確に `f` を `last - first` 回適用する @@ -72,7 +101,7 @@ for_each_result { ## 例 - +### 基本的な使い方 ```cpp example #include #include @@ -105,6 +134,35 @@ int main() { 6 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5}; + + // 並列に全ての要素を2倍にする + std::ranges::for_each(std::execution::par, v, [](int& x) { x *= 2; }); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::for_each[color ff0000] + +#### 出力 +``` +2 4 6 8 10 +``` + +## バージョン +### 言語 +- C++20 ### 処理系 - [Clang](/implementation.md#clang): ?? @@ -112,7 +170,6 @@ int main() { - [ICC](/implementation.md#icc): ?? - [Visual C++](/implementation.md#visual_cpp): 2019 Update 10 [mark verified] - ## 実装例 ```cpp struct for_each_impl { @@ -142,3 +199,4 @@ inline constexpr for_each_impl for_each; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_for_each_n.md b/reference/algorithm/ranges_for_each_n.md index 7095a7aebb..241ab8d8a3 100644 --- a/reference/algorithm/ranges_for_each_n.md +++ b/reference/algorithm/ranges_for_each_n.md @@ -14,14 +14,29 @@ namespace std::ranges { iter_difference_t n, Fun f, Proj proj = {}); // (1) C++20 + + template > Fun> + I for_each_n(Ep&& exec, + I first, + iter_difference_t n, + Fun f, + Proj proj = {}); // (2) C++26 } ``` * indirectly_unary_invocable[link /reference/iterator/indirectly_unary_invocable.md] * for_each_n_result[link /reference/algorithm/ranges_in_fun_result.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 範囲の先頭N個の要素に、指定された関数を適用する。 +- (1): 通常版 +- (2): 並列アルゴリズム版。実行ポリシーを指定する + ## テンプレートパラメータ制約 - `I`が[`input_iterator`](/reference/iterator/input_iterator.md)である - `Fun`は`I`を`Proj`で射影した値を受け取る[1引数の`invocable`](/reference/iterator/indirectly_unary_invocable.md)である @@ -38,18 +53,22 @@ namespace std::ranges { このアルゴリズムはその他のアルゴリズムと違い、[`invoke`](/reference/functional/invoke.md)`(proj, *i)` が書き換え可能な参照であれば、関数 `f` の内部でその値を書き換えても構わない。 ## 戻り値 -```cpp -for_each_n_result { - .in = first + n, - .fun = std::move(f) -} -``` -* for_each_n_result[link /reference/algorithm/ranges_in_fun_result.md] +- (1): + ```cpp + for_each_n_result { + .in = first + n, + .fun = std::move(f) + } + ``` + * for_each_n_result[link /reference/algorithm/ranges_in_fun_result.md] + +- (2): `first + n` ## 備考 - 関数 `f` に戻り値がある場合、それは単に無視される ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -84,6 +103,33 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5}; + + // 並列に先頭3要素を出力 + std::ranges::for_each_n(std::execution::par, v.begin(), 3, + [](int x) { std::cout << x << ' '; }); + std::cout << std::endl; +} +``` +* std::ranges::for_each_n[color ff0000] + +#### 出力例 +``` +1 2 3 +``` + +## バージョン +### 言語 +- C++20 + ### 処理系 - [Clang](/implementation.md#clang): ?? - [GCC](/implementation.md#gcc): 10.1.0 [mark verified] @@ -113,3 +159,4 @@ inline constexpr for_each_n_impl for_each_n; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_generate.md b/reference/algorithm/ranges_generate.md index 45d70770d7..0ccfffdd46 100644 --- a/reference/algorithm/ranges_generate.md +++ b/reference/algorithm/ranges_generate.md @@ -13,25 +13,50 @@ namespace std::ranges { constexpr O generate(O first, S last, - F gen); // (1) C++20 + F gen); // (1) C++20 template requires invocable && output_range> constexpr borrowed_iterator_t generate(R&& r, - F gen); // (2) C++20 + F gen); // (2) C++20 + + template S, + copy_constructible F> + requires invocable && indirectly_writable> + O generate(Ep&& exec, + O first, + S last, + F gen); // (3) C++26 + + template + requires invocable && indirectly_writable, invoke_result_t> + borrowed_iterator_t + generate(Ep&& exec, + R&& r, + F gen); // (4) C++26 } ``` * input_or_output_iterator[link /reference/iterator/input_or_output_iterator.md] * indirectly_writable[link /reference/iterator/indirectly_writable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 出力の範囲へ関数の結果を書き込む。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -47,6 +72,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -71,6 +97,32 @@ int main() { 1,2,4,8,16,32,64,128,256,512, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v(10); + + // 並列に全要素を99で埋める + std::ranges::generate(std::execution::par, v, [] { return 99; }); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::generate[color ff0000] + +#### 出力 +``` +99 99 99 99 99 99 99 99 99 99 +``` + ## バージョン ### 言語 - C++20 @@ -83,3 +135,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_generate_n.md b/reference/algorithm/ranges_generate_n.md index 6f06cec132..56f5f2c9d3 100644 --- a/reference/algorithm/ranges_generate_n.md +++ b/reference/algorithm/ranges_generate_n.md @@ -13,15 +13,29 @@ namespace std::ranges { generate_n(O first, iter_difference_t n, F gen); // (1) C++20 + + template + requires invocable && indirectly_writable> + O generate_n(Ep&& exec, + O first, + iter_difference_t n, + F gen); // (2) C++26 } ``` * input_or_output_iterator[link /reference/iterator/input_or_output_iterator.md] * indirectly_writable[link /reference/iterator/indirectly_writable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 出力の範囲へ関数の結果を `n` 個書き込む。 +- (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する + ## 効果 `n` が 1 以上の場合、`[first,last)` のそれぞれのイテレータについて関数オブジェクト `gen` を呼び出し、その戻り値を代入する。 @@ -41,6 +55,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -59,6 +74,35 @@ int main() { 1,2,4,8,16,32,64,128,256,512, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include +#include + +int main() { + std::vector v(5); + + // 並列に値を生成して書き込む + std::atomic counter{0}; + std::ranges::generate_n(std::execution::par, v.begin(), 5, + [&counter] { return counter++; }); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::generate_n[color ff0000] + +#### 出力例 +``` +0 1 2 3 4 +``` + ## バージョン ### 言語 - C++20 @@ -71,3 +115,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_in_in_out_result.md b/reference/algorithm/ranges_in_in_out_result.md index 4939125fe3..095b4a90fd 100644 --- a/reference/algorithm/ranges_in_in_out_result.md +++ b/reference/algorithm/ranges_in_in_out_result.md @@ -3,7 +3,7 @@ * std::ranges[meta namespace] * class template[meta id-type] * cpp20[meta cpp] -* binary_transform_result,merge_result,set_union_result,set_intersection_result,set_symmetric_difference_result[meta alias] +* binary_transform_result,merge_result,set_union_result,set_intersection_result,set_symmetric_difference_result,reverse_copy_truncated_result,rotate_copy_truncated_result[meta alias] ```cpp namespace std::ranges { @@ -50,6 +50,14 @@ namespace std::ranges { // (6) template using set_symmetric_difference_result = in_in_out_result; + + // (7) C++26 + template + using reverse_copy_truncated_result = in_in_out_result; + + // (8) C++26 + template + using rotate_copy_truncated_result = in_in_out_result; } ``` * no_unique_address[link /lang/cpp20/language_support_for_empty_objects.md] @@ -62,6 +70,8 @@ namespace std::ranges { * (4): [`ranges::set_union`](ranges_set_union.md)で使用するエイリアス * (5): [`ranges::set_intersection`](ranges_set_intersection.md)で使用するエイリアス * (6): [`ranges::set_symmetric_difference`](ranges_set_symmetric_difference.md)で使用するエイリアス +* (7): [`ranges::reverse_copy`](ranges_reverse_copy.md)の並列アルゴリズム版で使用するエイリアス (C++26) +* (8): [`ranges::rotate_copy`](ranges_rotate_copy.md)の並列アルゴリズム版で使用するエイリアス (C++26) この型は、関数が2つの入力用の範囲と出力用の範囲を受け取る場合に、それぞれ処理した範囲の末尾を返すために使用される。 @@ -125,3 +135,5 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) +- [P3709R2 Reconsider parallel `ranges::rotate_copy` and `ranges::reverse_copy`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3709r2.html) diff --git a/reference/algorithm/ranges_includes.md b/reference/algorithm/ranges_includes.md index 41e5babb6d..403ec100f0 100644 --- a/reference/algorithm/ranges_includes.md +++ b/reference/algorithm/ranges_includes.md @@ -39,16 +39,60 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Proj1 = identity, + class Proj2 = identity, + indirect_strict_weak_order< + projected, + projected + > Comp = ranges::less> + bool + includes(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template , Proj1>, + projected, Proj2> + > Comp = ranges::less> + bool + includes(Ep&& exec, + R1&& r1, + R2&& r2, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つのソート済み範囲において、一方の範囲の要素がもう一方の範囲に全て含まれているかを判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 `[first2,last2)` が `empty` であるか、`[first2,last2)` の全ての要素が `[first1,last1)` に含まれている場合は `true`、そうでない場合は `false` を返す。 @@ -59,6 +103,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -84,6 +129,34 @@ true false ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector a = {1, 2, 3, 4, 5, 6}; + std::vector b = {2, 4, 6}; + std::vector c = {2, 4, 7}; + + std::cout << std::boolalpha; + + // 並列にaがbの全要素を含むか判定する + std::cout << std::ranges::includes(std::execution::par, a, b) << std::endl; + std::cout << std::ranges::includes(std::execution::par, a, c) << std::endl; +} +``` +* std::ranges::includes[color ff0000] + +#### 出力 +``` +true +false +``` + ## バージョン ### 言語 - C++20 @@ -96,3 +169,4 @@ false ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_inplace_merge.md b/reference/algorithm/ranges_inplace_merge.md index 58cfe9bb48..5d12106d2f 100644 --- a/reference/algorithm/ranges_inplace_merge.md +++ b/reference/algorithm/ranges_inplace_merge.md @@ -47,17 +47,49 @@ namespace std::ranges { iterator_t middle, Comp comp = {}, Proj proj = {}); // (2) C++26 + + template S, + class Comp = ranges::less, + class Proj = identity> + requires sortable + I + inplace_merge(Ep&& exec, + I first, + I middle, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template + requires sortable, Comp, Proj> + borrowed_iterator_t + inplace_merge(Ep&& exec, + R&& r, + iterator_t middle, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * sortable[link /reference/iterator/sortable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つの連続したソート済み範囲をマージする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,middle)` と `[middle,last)` の範囲はそれぞれソートされていること。 @@ -83,6 +115,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -112,6 +145,34 @@ int main() 6 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 3, 5, 2, 4, 6}; + + // 並列にインプレースマージ + // [1,3,5) と [2,4,6) をマージ + std::ranges::inplace_merge(std::execution::par, + v, v.begin() + 3); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::inplace_merge[color ff0000] + +#### 出力 +``` +1 2 3 4 5 6 +``` + ## 実装例 - [`inplace_merge` を読んでみた](http://www.kmonos.net/wlog/115.html#_2300101215) @@ -129,3 +190,4 @@ int main() - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2562R1 `constexpr` Stable Sorting](https://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2562r1.pdf) - C++26から`constexpr`に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_is_heap.md b/reference/algorithm/ranges_is_heap.md index 35abb8e9fa..394cfad5dd 100644 --- a/reference/algorithm/ranges_is_heap.md +++ b/reference/algorithm/ranges_is_heap.md @@ -23,16 +23,44 @@ namespace std::ranges { is_heap(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + bool + is_heap(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + bool + is_heap(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲がヒープ化されているか判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -40,6 +68,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -68,6 +97,36 @@ before: is heap? false after: is heap? true ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5}; + + std::cout << std::boolalpha; + std::cout << "before: is heap? " + << std::ranges::is_heap(std::execution::par, v) << std::endl; + + std::ranges::make_heap(v); + + std::cout << " after: is heap? " + << std::ranges::is_heap(std::execution::par, v) << std::endl; +} +``` +* std::ranges::is_heap[color ff0000] +* std::ranges::make_heap[link ranges_make_heap.md] + +#### 出力 +``` +before: is heap? false + after: is heap? true +``` + ## バージョン ### 言語 - C++20 @@ -80,3 +139,4 @@ before: is heap? false ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_is_heap_until.md b/reference/algorithm/ranges_is_heap_until.md index d96bc5c22c..ae11489844 100644 --- a/reference/algorithm/ranges_is_heap_until.md +++ b/reference/algorithm/ranges_is_heap_until.md @@ -23,16 +23,44 @@ namespace std::ranges { is_heap_until(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + I is_heap_until(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + borrowed_iterator_t + is_heap_until(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] +* borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲がヒープ化されているか判定し、ヒープ化されていない最初の要素を指すイテレータを取得する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -44,6 +72,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -66,12 +95,39 @@ int main() * std::ranges::is_heap_until[color ff0000] * std::ranges::make_heap[link ranges_make_heap.md] -### 出力 +#### 出力 ``` before: is heap? false after: is heap? true ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {9, 5, 7, 3, 1, 2, 4}; + + // 並列にヒープ条件を満たさなくなる位置を検索 + auto it = std::ranges::is_heap_until(std::execution::par, v); + + std::cout << "heap part: "; + for (auto i = v.begin(); i != it; ++i) { + std::cout << *i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::is_heap_until[color ff0000] + +#### 出力 +``` +heap part: 9 5 7 3 1 2 4 +``` + ## バージョン ### 言語 - C++20 @@ -84,3 +140,4 @@ before: is heap? false ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_is_partitioned.md b/reference/algorithm/ranges_is_partitioned.md index ffff76a496..d620305c0a 100644 --- a/reference/algorithm/ranges_is_partitioned.md +++ b/reference/algorithm/ranges_is_partitioned.md @@ -23,14 +23,40 @@ namespace std::ranges { is_partitioned(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + bool is_partitioned(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + bool is_partitioned(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 与えられた範囲が条件によって[区分化](/reference/algorithm.md#sequence-is-partitioned)されているか判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -44,6 +70,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -84,6 +111,33 @@ int main() partitioned ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {2, 4, 6, 1, 3, 5}; + + auto pred = [](int x) { return x % 2 == 0; }; + + // 並列に偶数グループと奇数グループに分かれているか判定する + std::cout << std::boolalpha; + std::cout << "is partitioned? " + << std::ranges::is_partitioned(std::execution::par, v, pred) + << std::endl; +} +``` +* std::ranges::is_partitioned[color ff0000] + +#### 出力 +``` +is partitioned? true +``` + ## バージョン ### 言語 - C++20 @@ -96,3 +150,4 @@ partitioned ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_is_sorted.md b/reference/algorithm/ranges_is_sorted.md index b5bf9efb07..cedf3488ae 100644 --- a/reference/algorithm/ranges_is_sorted.md +++ b/reference/algorithm/ranges_is_sorted.md @@ -23,16 +23,42 @@ namespace std::ranges { is_sorted(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + bool is_sorted(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + bool is_sorted(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 与えられた範囲がソート済みか判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ### 戻り値 @@ -40,6 +66,7 @@ namespace std::ranges { - (2) : [`ranges::is_sorted_until`](/reference/algorithm/ranges_is_sorted_until.md)`(r, comp, proj) == last` ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -66,6 +93,36 @@ before: is sorted? false after: is sorted? true ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + std::cout << std::boolalpha; + std::cout << "before: is sorted? " + << std::ranges::is_sorted(std::execution::par, v) << std::endl; + + std::ranges::sort(v); + + std::cout << " after: is sorted? " + << std::ranges::is_sorted(std::execution::par, v) << std::endl; +} +``` +* std::ranges::is_sorted[color ff0000] +* std::ranges::sort[link ranges_sort.md] + +#### 出力 +``` +before: is sorted? false + after: is sorted? true +``` + ## バージョン ### 言語 - C++20 @@ -78,3 +135,4 @@ before: is sorted? false ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_is_sorted_until.md b/reference/algorithm/ranges_is_sorted_until.md index d01cf16df7..b92c0af1ce 100644 --- a/reference/algorithm/ranges_is_sorted_until.md +++ b/reference/algorithm/ranges_is_sorted_until.md @@ -23,17 +23,44 @@ namespace std::ranges { is_sorted_until(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + I is_sorted_until(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + borrowed_iterator_t + is_sorted_until(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 ソート済みか判定し、ソートされていない位置のイテレータを取得する - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 [`distance`](/reference/iterator/distance.md)`(first, last) < 2` なら `last` を返す。そうでない場合、`[first,last]` の中でソートされている範囲を `[first,i)` としたとき、そのイテレータ `i` を返す。 @@ -44,6 +71,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -72,6 +100,33 @@ before: is sorted? false ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {1, 2, 3, 5, 4, 6}; + + // 並列にソート済み範囲の終端を取得する + auto it = std::ranges::is_sorted_until(std::execution::par, v); + + std::cout << "sorted until: " << *it << std::endl; + std::cout << "sorted range size: " << (it - v.begin()) << std::endl; +} +``` +* std::ranges::is_sorted_until[color ff0000] +* v.begin()[link /reference/vector/vector/begin.md] + +#### 出力 +``` +sorted until: 4 +sorted range size: 4 +``` + ## 実装例 ```cpp @@ -115,3 +170,4 @@ inline constexpr is_sorted_until_impl is_sorted_until; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_lexicographical_compare.md b/reference/algorithm/ranges_lexicographical_compare.md index 80fb244482..059fcca8d1 100644 --- a/reference/algorithm/ranges_lexicographical_compare.md +++ b/reference/algorithm/ranges_lexicographical_compare.md @@ -40,16 +40,58 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Proj1 = identity, + class Proj2 = identity, + indirect_strict_weak_order< + projected, + projected + > Comp = ranges::less> + bool lexicographical_compare(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template , Proj1>, + projected, Proj2> + > Comp = ranges::less> + bool lexicographical_compare(Ep&& exec, + R1&& r1, + R2&& r2, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 `[first1, last1)`および`[first2, last2)`の2つの範囲を辞書式順序で比較する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 ```cpp @@ -76,6 +118,7 @@ return first1 == last1 && first2 != last2; ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -136,6 +179,36 @@ x less than y x less than y ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector a = {1, 2, 3, 4, 5}; + std::vector b = {1, 2, 3, 4, 6}; + + // 並列に辞書式比較を行う + bool result = std::ranges::lexicographical_compare( + std::execution::par, + a, + b + ); + + std::cout << std::boolalpha; + std::cout << "a < b: " << result << std::endl; +} +``` +* std::ranges::lexicographical_compare[color ff0000] + +#### 出力 +``` +a < b: true +``` + ## バージョン ### 言語 - C++20 @@ -148,3 +221,4 @@ x less than y ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_max.md b/reference/algorithm/ranges_max.md index 32ca3a62fb..8fa065d48e 100644 --- a/reference/algorithm/ranges_max.md +++ b/reference/algorithm/ranges_max.md @@ -31,12 +31,25 @@ namespace std::ranges { max(R&& r, Comp comp = {}, Proj proj = {}); // (3) C++20 + + template , Proj>> Comp = ranges::less> + requires indirectly_copyable_storable, range_value_t*> + range_value_t + max(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] * initializer_list[link /reference/initializer_list/initializer_list.md] * indirectly_copyable_storable[link /reference/iterator/indirectly_copyable_storable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 同じ型の2つの値、もしくは範囲によるN個の値のうち、最大値を取得する。 @@ -44,6 +57,7 @@ namespace std::ranges { - (1): 2つの値を指定する - (2): 初期化子リストを指定する - (3): Rangeを指定する +- (4): (3)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -53,6 +67,7 @@ namespace std::ranges { - 等価な要素が 2 つ以上あった場合には、最も左の要素を返す。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -90,6 +105,28 @@ Windows環境においては、``をインクルードすると`max` - ``をインクルードするまでに`#define NOMINMAX`を行う。これで`max`マクロが定義されなくなる。 - `std::ranges::max()`を呼び出す際に、`(std::ranges::max)(a, b);`のように関数名をカッコで囲んで使用する。これで、名前解決において`std::ranges::max()`関数が必ず使用される。 +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に最大値を取得 + int result = std::ranges::max(std::execution::par, v); + std::cout << result << std::endl; +} +``` +* std::ranges::max[color ff0000] + +#### 出力 +``` +9 +``` + ## バージョン ### 言語 - C++20 @@ -102,3 +139,4 @@ Windows環境においては、``をインクルードすると`max` ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_max_element.md b/reference/algorithm/ranges_max_element.md index eebec0f04a..88e4a3e42d 100644 --- a/reference/algorithm/ranges_max_element.md +++ b/reference/algorithm/ranges_max_element.md @@ -23,17 +23,44 @@ namespace std::ranges { max_element(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + I max_element(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + borrowed_iterator_t + max_element(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 `[first, last)`の範囲において、最大要素を指す最初のイテレータを取得する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -43,6 +70,7 @@ namespace std::ranges { [`max`](max.md)`((last - first) - 1, 0)`回の比較を行う ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -70,6 +98,30 @@ int main() ``` ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に最大要素を検索する + auto it = std::ranges::max_element(std::execution::par, v); + + std::cout << "max: " << *it << std::endl; +} +``` +* std::ranges::max_element[color ff0000] + +#### 出力 +``` +max: 9 +``` + ## バージョン ### 言語 - C++20 @@ -82,3 +134,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_merge.md b/reference/algorithm/ranges_merge.md index 739eace4ed..83440d5a85 100644 --- a/reference/algorithm/ranges_merge.md +++ b/reference/algorithm/ranges_merge.md @@ -43,6 +43,50 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + random_access_iterator O, + sized_sentinel_for OutS, + class Comp = ranges::less, + class Proj1 = identity, + class Proj2 = identity> + requires mergeable + merge_result + merge(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + O result, + OutS result_last, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires mergeable, iterator_t, iterator_t, Comp, Proj1, Proj2> + merge_result< + borrowed_iterator_t, + borrowed_iterator_t, + borrowed_iterator_t + > + merge(Ep&& exec, + R1&& r1, + R2&& r2, + OutR&& result_r, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * merge_result[link ranges_in_in_out_result.md] @@ -50,12 +94,18 @@ namespace std::ranges { * ranges::less[link /reference/functional/ranges_less.md] * mergeable[link /reference/iterator/mergeable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つのソート済み範囲をマージして、出力イテレータへ出力する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -85,6 +135,7 @@ merge_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -122,6 +173,35 @@ int main() 6 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector a = {1, 3, 5, 7}; + std::vector b = {2, 4, 6, 8}; + std::vector result(a.size() + b.size()); + + // 並列に2つのソート済み範囲をマージする + std::ranges::merge(std::execution::par, a, b, result); + + for (int x : result) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::merge[color ff0000] + +#### 出力 +``` +1 2 3 4 5 6 7 8 +``` + ## バージョン ### 言語 - C++20 @@ -134,3 +214,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_min.md b/reference/algorithm/ranges_min.md index f3ec69f0d4..49775810a6 100644 --- a/reference/algorithm/ranges_min.md +++ b/reference/algorithm/ranges_min.md @@ -31,12 +31,25 @@ namespace std::ranges { min(R&& r, Comp comp = {}, Proj proj = {}); // (3) C++20 + + template , Proj>> Comp = ranges::less> + requires indirectly_copyable_storable, range_value_t*> + range_value_t + min(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] * initializer_list[link /reference/initializer_list/initializer_list.md] * indirectly_copyable_storable[link /reference/iterator/indirectly_copyable_storable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 同じ型の2つの値、もしくは範囲によるN個の値のうち、最小値を取得する。 @@ -44,6 +57,7 @@ namespace std::ranges { - (1): 2つの値を指定する - (2): 初期化子リストを指定する - (3): Rangeを指定する +- (4): (3)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -54,6 +68,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -91,6 +106,28 @@ Windows環境においては、``をインクルードすると`min` - ``をインクルードするまでに`#define NOMINMAX`を行う。これで`min`マクロが定義されなくなる。 - `std::ranges::min()`を呼び出す際に、`(std::ranges::min)(a, b);`のように関数名をカッコで囲んで使用する。これで、名前解決において`std::ranges::min()`が必ず使用される。 +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に最小値を取得 + int result = std::ranges::min(std::execution::par, v); + std::cout << result << std::endl; +} +``` +* std::ranges::min[color ff0000] + +#### 出力 +``` +1 +``` + ## バージョン ### 言語 - C++20 @@ -103,3 +140,4 @@ Windows環境においては、``をインクルードすると`min` ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_min_element.md b/reference/algorithm/ranges_min_element.md index e7c039f0ff..67b5dc891e 100644 --- a/reference/algorithm/ranges_min_element.md +++ b/reference/algorithm/ranges_min_element.md @@ -23,11 +23,36 @@ namespace std::ranges { min_element(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + I min_element(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + borrowed_iterator_t + min_element(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -35,6 +60,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -46,6 +73,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -73,6 +101,30 @@ int main() ``` ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に最小要素を検索する + auto it = std::ranges::min_element(std::execution::par, v); + + std::cout << "min: " << *it << std::endl; +} +``` +* std::ranges::min_element[color ff0000] + +#### 出力 +``` +min: 1 +``` + ## バージョン ### 言語 - C++20 @@ -85,3 +137,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_minmax.md b/reference/algorithm/ranges_minmax.md index 2f678c217e..22b63c906a 100644 --- a/reference/algorithm/ranges_minmax.md +++ b/reference/algorithm/ranges_minmax.md @@ -31,6 +31,17 @@ namespace std::ranges { minmax(R&& r, Comp comp = {}, Proj proj = {}); // (3) C++20 + + template , Proj>> Comp = ranges::less> + requires indirectly_copyable_storable, range_value_t*> + minmax_result> + minmax(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * minmax_result[link ranges_min_max_result.md] @@ -38,6 +49,8 @@ namespace std::ranges { * ranges::less[link /reference/functional/ranges_less.md] * initializer_list[link /reference/initializer_list/initializer_list.md] * indirectly_copyable_storable[link /reference/iterator/indirectly_copyable_storable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 同じ型の2つの値、もしくは範囲によるN個の値のうち、最小値と最大値の組を取得する。 @@ -45,6 +58,7 @@ namespace std::ranges { - (1): 2つの値を指定する - (2): 初期化子リストを指定する - (3): Rangeを指定する +- (4): (3)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -63,6 +77,7 @@ minmax_result { - 範囲バージョンは高々`(3/2) * t.size()`回の述語適用。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -93,6 +108,28 @@ int main() ``` ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に最小値と最大値を取得 + auto [min_val, max_val] = std::ranges::minmax(std::execution::par, v); + std::cout << min_val << ", " << max_val << std::endl; +} +``` +* std::ranges::minmax[color ff0000] + +#### 出力 +``` +1, 9 +``` + ## バージョン ### 言語 - C++20 @@ -105,3 +142,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_minmax_element.md b/reference/algorithm/ranges_minmax_element.md index a243db083e..332cc08d74 100644 --- a/reference/algorithm/ranges_minmax_element.md +++ b/reference/algorithm/ranges_minmax_element.md @@ -23,12 +23,38 @@ namespace std::ranges { minmax_element(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_strict_weak_order> Comp = ranges::less> + minmax_element_result + minmax_element(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> Comp = ranges::less> + minmax_element_result> + minmax_element(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * minmax_element_result[link ranges_min_max_result.md] * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * ranges::less[link /reference/functional/ranges_less.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -36,6 +62,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -53,6 +81,7 @@ minmax_element_result { `n` を範囲の要素数とする場合、[`max`](max.md)`(floor(3(n - 1) / 2), 0)` 回の述語適用を行う。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -77,6 +106,32 @@ int main() ``` ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6}; + + // 並列に最小要素と最大要素を同時に検索する + auto [min_it, max_it] = std::ranges::minmax_element(std::execution::par, v); + + std::cout << "min: " << *min_it << std::endl; + std::cout << "max: " << *max_it << std::endl; +} +``` +* std::ranges::minmax_element[color ff0000] + +#### 出力 +``` +min: 1 +max: 9 +``` + ## バージョン ### 言語 - C++20 @@ -89,3 +144,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_mismatch.md b/reference/algorithm/ranges_mismatch.md index e45983580d..0d062d1d15 100644 --- a/reference/algorithm/ranges_mismatch.md +++ b/reference/algorithm/ranges_mismatch.md @@ -38,10 +38,51 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + mismatch_result + mismatch(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + mismatch_result< + borrowed_iterator_t, + borrowed_iterator_t + > + mismatch(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * mismatch_result[link ranges_in_in_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -49,6 +90,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -66,6 +109,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -107,7 +151,7 @@ int main() { * std::ranges::mismatch[color ff0000] * std::to_string[link /reference/string/to_string.md] -### 出力 +#### 出力 ``` mismatch index: 2 mismatch value: (3,4) @@ -117,6 +161,35 @@ mismatch value: (end,2) ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v1 = {1, 2, 3, 4, 5}; + std::vector v2 = {1, 2, 4, 4, 5}; + + // 並列に2つのシーケンスが異なる場所を探す + auto [it1, it2] = std::ranges::mismatch(std::execution::par, v1, v2); + if (it1 == v1.end()) { + std::cout << "all match" << std::endl; + } else { + std::cout << "mismatch at index: " << std::distance(v1.begin(), it1) << std::endl; + std::cout << "values: " << *it1 << " vs " << *it2 << std::endl; + } +} +``` +* std::ranges::mismatch[color ff0000] + +#### 出力 +``` +mismatch at index: 2 +values: 3 vs 4 +``` + ## 実装例 ```cpp struct mismatch_impl { @@ -158,3 +231,4 @@ inline constexpr mismatch_impl mismatch; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_move.md b/reference/algorithm/ranges_move.md index 08ab3cf3cd..f489ba6667 100644 --- a/reference/algorithm/ranges_move.md +++ b/reference/algorithm/ranges_move.md @@ -13,26 +13,54 @@ namespace std::ranges { constexpr move_result move(I first, S last, - O result); // (1) C++20 + O result); // (1) C++20 template requires indirectly_movable, O> constexpr move_result, O> move(R&& r, - O result); // (2) C++20 + O result); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS> + requires indirectly_movable + move_result + move(Ep&& exec, + I first, + S last, + O result, + OutS result_last); // (3) C++26 + + template + requires indirectly_movable, iterator_t> + move_result, borrowed_iterator_t> + move(Ep&& exec, + R&& r, + OutR&& result_r); // (4) C++26 } ``` * move_result[link ranges_in_out_result.md] * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_movable[link /reference/iterator/indirectly_movable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された範囲の要素をムーブする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -59,6 +87,7 @@ move_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -93,6 +122,34 @@ int main() { 4 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include +#include + +int main() { + std::vector src = {"hello", "world", "foo", "bar", "baz"}; + std::vector dst(src.size()); + + // 並列にムーブする + std::ranges::move(std::execution::par, src, dst); + + for (const auto& s : dst) { + std::cout << s << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::move[color ff0000] + +#### 出力 +``` +hello world foo bar baz +``` + ## バージョン ### 言語 - C++20 @@ -105,3 +162,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_move_backward.md b/reference/algorithm/ranges_move_backward.md index 4e6ab8bb61..059f1c1bc2 100644 --- a/reference/algorithm/ranges_move_backward.md +++ b/reference/algorithm/ranges_move_backward.md @@ -13,25 +13,51 @@ namespace std::ranges { constexpr move_backward_result move_backward(I1 first, S1 last, - I2 result); // (1) C++20 + I2 result); // (1) C++20 template requires indirectly_movable, I> constexpr move_backward_result, I> move_backward(R&& r, - I result); // (2) C++20 + I result); // (2) C++20 + + template S1, + random_access_iterator I2> + requires indirectly_movable + move_backward_result + move_backward(Ep&& exec, + I1 first, + S1 last, + I2 result); // (3) C++26 + + template + requires indirectly_movable, I> + move_backward_result, I> + move_backward(Ep&& exec, + R&& r, + I result); // (4) C++26 } ``` * move_backward_result[link ranges_in_out_result.md] * indirectly_movable[link /reference/iterator/indirectly_movable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された範囲の要素を後ろからムーブする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 `result` は `(first,last]` の範囲に含まれてはならない。 @@ -61,6 +87,7 @@ move_backward_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -104,6 +131,33 @@ int main() { 2 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 0, 0}; + + // 並列に先頭3要素を後方へムーブ + std::ranges::move_backward(std::execution::par, + v.begin(), v.begin() + 3, v.end()); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::move_backward[color ff0000] + +#### 出力 +``` +1 2 1 2 3 +``` + ## バージョン ### 言語 - C++20 @@ -116,3 +170,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_none_of.md b/reference/algorithm/ranges_none_of.md index 9d3bc4f7a6..1a3c07c175 100644 --- a/reference/algorithm/ranges_none_of.md +++ b/reference/algorithm/ranges_none_of.md @@ -23,14 +23,40 @@ namespace std::ranges { none_of(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + bool none_of(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + bool none_of(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の全ての要素が条件を満たさないかを判定する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 - (1): @@ -62,6 +88,7 @@ all_of(first, last, not_fn(pred)); ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -83,12 +110,37 @@ int main() { ``` * std::ranges::none_of[color ff0000] -### 出力 +#### 出力 ``` false true ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 3, 5, 7, 9}; + + std::cout << std::boolalpha; + + // 並列に全ての要素が偶数でないかを判定 + bool result = std::ranges::none_of(std::execution::par, v, + [](int x) { return x % 2 == 0; }); + std::cout << result << std::endl; +} +``` +* std::ranges::none_of[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp struct none_of_impl { @@ -131,3 +183,4 @@ inline constexpr none_of_impl none_of; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_nth_element.md b/reference/algorithm/ranges_nth_element.md index 46e6a0f6e5..1ef170c401 100644 --- a/reference/algorithm/ranges_nth_element.md +++ b/reference/algorithm/ranges_nth_element.md @@ -27,11 +27,39 @@ namespace std::ranges { iterator_t nth, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Comp = ranges::less, + class Proj = identity> + requires sortable + I nth_element(Ep&& exec, + I first, + I nth, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template + requires sortable, Comp, Proj> + borrowed_iterator_t + nth_element(Ep&& exec, + R&& r, + iterator_t nth, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * sortable[link /reference/iterator/sortable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -39,6 +67,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する この関数は範囲 `[first,last)` の並び替えを行うが、基準位置 `nth` のみが正しい要素、つまり仮に範囲 `[first,last)` 全体を並び替えた際に`nth`に位置すべき要素となる。前半の範囲 `[first,nth)` は関数呼び出し後の位置 `nth` にある要素よりも小さいことは保証されるが、その範囲 `[first,nth)` 内での要素並び順はなんら保証されない。 @@ -56,6 +86,7 @@ namespace std::ranges { 平均で線形時間 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -88,6 +119,37 @@ int main() 10 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {5, 10, 4, 7, 1, 9, 8, 6, 2}; + + // 並列に4番目に小さい値より小さい値を前に集める + std::ranges::nth_element(std::execution::par, v, v.begin() + 3); + + std::cout << "4th element: " << v[3] << std::endl; + + for (int i : v) { + std::cout << i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::nth_element[color ff0000] +* v.begin()[link /reference/vector/vector/begin.md] + +#### 出力例 +``` +4th element: 5 +2 1 4 5 7 6 8 9 10 +``` + ## バージョン ### 言語 - C++20 @@ -100,3 +162,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_partial_sort.md b/reference/algorithm/ranges_partial_sort.md index e5e6cfcb84..fca20788b6 100644 --- a/reference/algorithm/ranges_partial_sort.md +++ b/reference/algorithm/ranges_partial_sort.md @@ -27,11 +27,39 @@ namespace std::ranges { iterator_t middle, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Comp = ranges::less, + class Proj = identity> + requires sortable + I partial_sort(Ep&& exec, + I first, + I middle, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template + requires sortable, Comp, Proj> + borrowed_iterator_t + partial_sort(Ep&& exec, + R&& r, + iterator_t middle, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * sortable[link /reference/iterator/sortable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -39,6 +67,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する この関数は、「売り上げランキング トップ1位から10位まで」のように、全体ではなく最高順位から途中までの順位がわかればよい状況で、全体を並び替える[`sort()`](sort.md)関数の代わりに使用できる。 @@ -56,6 +86,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -81,6 +112,34 @@ int main() 12435 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}; + + // 並列に先頭3要素を並んだ状態にする + std::ranges::partial_sort(std::execution::par, v, v.begin() + 3); + + for (int i : v) { + std::cout << i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::partial_sort[color ff0000] +* v.begin()[link /reference/vector/vector/begin.md] + +#### 出力例 +``` +1 1 2 4 5 9 3 6 5 3 5 +``` + ## バージョン ### 言語 - C++20 @@ -93,3 +152,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_partial_sort_copy.md b/reference/algorithm/ranges_partial_sort_copy.md index bb5a1dd34f..6ba612c0aa 100644 --- a/reference/algorithm/ranges_partial_sort_copy.md +++ b/reference/algorithm/ranges_partial_sort_copy.md @@ -42,6 +42,48 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Comp = ranges::less, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_copyable && + sortable && + indirect_strict_weak_order, projected> + partial_sort_copy_result + partial_sort_copy(Ep&& exec, + I1 first, + S1 last, + I2 result_first, + S2 result_last, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_copyable, iterator_t> && + sortable, Comp, Proj2> && + indirect_strict_weak_order< + Comp, + projected, Proj1>, + projected, Proj2> + > + partial_sort_copy_result, borrowed_iterator_t> + partial_sort_copy(Ep&& exec, + R1&& r, + R2&& result_r, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * partial_sort_copy_result[link ranges_in_out_result.md] @@ -50,12 +92,18 @@ namespace std::ranges { * indirect_strict_weak_order[link /reference/iterator/indirect_strict_weak_order.md] * sortable[link /reference/iterator/sortable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲を部分的にソートした結果を他の範囲にコピーする - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 `N =` [`min`](/reference/algorithm/min.md)`(last - first, result_last - result_first)` とする。 @@ -78,6 +126,7 @@ partial_sort_copy_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -104,6 +153,34 @@ int main() 12 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {3, 1, 4, 1, 5, 9, 2, 6}; + std::vector dst(3); + + // 並列に上位3個の要素をソートしてコピー + std::ranges::partial_sort_copy(std::execution::par, + src, dst); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::partial_sort_copy[color ff0000] + +#### 出力 +``` +1 1 2 +``` + ## バージョン ### 言語 - C++20 @@ -116,3 +193,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_partition.md b/reference/algorithm/ranges_partition.md index 6d73b817e1..a87c9e0d11 100644 --- a/reference/algorithm/ranges_partition.md +++ b/reference/algorithm/ranges_partition.md @@ -24,15 +24,45 @@ namespace std::ranges { partition(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + requires permutable + subrange + partition(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires permutable> + borrowed_subrange_t + partition(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 与えられた範囲を条件によって[区分化](/reference/algorithm.md#sequence-is-partitioned)する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -54,6 +84,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -93,6 +124,41 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {1, 2, 3, 4, 5, 6, 7, 8}; + + // 並列に偶数グループと奇数グループに分ける + auto boundary = std::ranges::partition(std::execution::par, v, [](int x) { return x % 2 == 0; }); + + std::cout << "even: "; + for (auto it = v.begin(); it != boundary.begin(); ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; + + std::cout << "odd: "; + for (int x : boundary) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::partition[color ff0000] + +#### 出力例 +``` +even: 8 2 6 4 +odd: 5 3 7 1 +``` + ## バージョン ### 言語 - C++20 @@ -105,3 +171,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_partition_copy.md b/reference/algorithm/ranges_partition_copy.md index 26ec256e38..0cf6d1f51b 100644 --- a/reference/algorithm/ranges_partition_copy.md +++ b/reference/algorithm/ranges_partition_copy.md @@ -33,12 +33,53 @@ namespace std::ranges { O2 out_false, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + random_access_iterator O1, + sized_sentinel_for OutS1, + random_access_iterator O2, + sized_sentinel_for OutS2, + class Proj = identity, + indirect_unary_predicate> Pred> + requires indirectly_copyable && indirectly_copyable + partition_copy_result + partition_copy(Ep&& exec, + I first, + S last, + O1 out_true, + OutS1 out_true_last, + O2 out_false, + OutS2 out_false_last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires indirectly_copyable, iterator_t> && + indirectly_copyable, iterator_t> + partition_copy_result, borrowed_iterator_t, borrowed_iterator_t> + partition_copy(Ep&& exec, + R&& r, + OutR1&& out_true, + OutR2&& out_false, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * partition_copy_result[link ranges_in_out_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -46,6 +87,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -64,6 +107,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -105,6 +149,45 @@ evens : 2,4, odds : 1,3,5, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5, 6, 7, 8}; + std::vector evens(8); + std::vector odds(8); + + // 並列に偶数と奇数に分類してコピー + auto [in_end, even_end, odd_end] = + std::ranges::partition_copy(std::execution::par, v, + evens, odds, + [](int x) { return x % 2 == 0; }); + + std::cout << "evens: "; + for (auto it = evens.begin(); it != even_end; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; + + std::cout << "odds: "; + for (auto it = odds.begin(); it != odd_end; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::partition_copy[color ff0000] + +#### 出力 +``` +evens: 2 4 6 8 +odds: 1 3 5 7 +``` + ## バージョン ### 言語 - C++20 @@ -117,3 +200,4 @@ odds : 1,3,5, ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_remove.md b/reference/algorithm/ranges_remove.md index 046703e18a..0ce717b591 100644 --- a/reference/algorithm/ranges_remove.md +++ b/reference/algorithm/ranges_remove.md @@ -53,15 +53,55 @@ namespace std::ranges { remove(R&& r, const T& value, Proj proj = {}); // (2) C++26 + + template S, + class T, + class Proj = identity> + requires permutable && + indirect_binary_predicate< + ranges::equal_to, + projected, + const T* + > + subrange + remove(Ep&& exec, + I first, + S last, + const T& value, + Proj proj = {}); // (3) C++26 + + template + requires permutable> && + indirect_binary_predicate< + ranges::equal_to, + projected, Proj>, + const T* + > + borrowed_subrange_t + remove(Ep&& exec, + R&& r, + const T& value, + Proj proj = {}); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された要素を取り除く。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -172,6 +212,34 @@ int main() { 5,6 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 2, 5, 2, 7}; + + // 並列に値2を除去する + auto result = std::ranges::remove(std::execution::par, v, 2); + v.erase(result.begin(), result.end()); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::remove[color ff0000] +* v.erase[link /reference/vector/vector/erase.md] + +#### 出力 +``` +1 3 5 7 +``` + ## バージョン ### 言語 - C++20 @@ -186,3 +254,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_remove_copy.md b/reference/algorithm/ranges_remove_copy.md index 68e13f9ee0..b241f71f86 100644 --- a/reference/algorithm/ranges_remove_copy.md +++ b/reference/algorithm/ranges_remove_copy.md @@ -71,18 +71,64 @@ namespace std::ranges { O result, const T& value, Proj proj = {}); // (2) C++26 + + template S, + random_access_iterator O, + sized_sentinel_for OutS, + class T, + class Proj = identity> + requires indirectly_copyable && + indirect_binary_predicate< + ranges::equal_to, + projected, + const T* + > + remove_copy_result + remove_copy(Ep&& exec, + I first, + S last, + O result, + OutS result_last, + const T& value, + Proj proj = {}); // (3) C++26 + + template + requires indirectly_copyable, iterator_t> && + indirect_binary_predicate< + ranges::equal_to, + projected, Proj>, + const T* + > + remove_copy_result, borrowed_iterator_t> + remove_copy(Ep&& exec, + R&& r, + OutR&& result_r, + const T& value, + Proj proj = {}); // (4) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * remove_copy_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された要素を除け、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,last)` と `[result,result + (last - first))` は重なってはならない。 @@ -174,6 +220,33 @@ int main() { ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 2, 5, 2, 7}; + std::vector dst(src.size()); + + // 並列に値2を除去してコピーする + auto result = std::ranges::remove_copy(std::execution::par, src, dst, 2); + + for (auto it = dst.begin(); it != result.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::remove_copy[color ff0000] + +#### 出力 +``` +1 3 5 7 +``` + ## バージョン ### 言語 - C++20 @@ -188,3 +261,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_remove_copy_if.md b/reference/algorithm/ranges_remove_copy_if.md index 2f0c10842a..369cf096e0 100644 --- a/reference/algorithm/ranges_remove_copy_if.md +++ b/reference/algorithm/ranges_remove_copy_if.md @@ -29,18 +29,54 @@ namespace std::ranges { O result, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS, + class Proj = identity, + indirect_unary_predicate> Pred> + requires indirectly_copyable + remove_copy_if_result + remove_copy_if(Ep&& exec, + I first, + S last, + O result, + OutS result_last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires indirectly_copyable, iterator_t> + remove_copy_if_result, borrowed_iterator_t> + remove_copy_if(Ep&& exec, + R&& r, + OutR&& result_r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * remove_copy_if_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 条件を満たす要素を除け、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,last)` と `[result,result + (last - first))` は重なってはならない。 @@ -63,6 +99,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -84,6 +121,34 @@ int main() { ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + std::vector dst(src.size()); + + // 並列に奇数を除去してコピーする + auto result = std::ranges::remove_copy_if(std::execution::par, src, dst, + [](int x) { return x % 2 != 0; }); + + for (auto it = dst.begin(); it != result.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::remove_copy_if[color ff0000] + +#### 出力 +``` +2 4 6 8 10 +``` + ## バージョン ### 言語 - C++20 @@ -96,3 +161,4 @@ int main() { ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_remove_if.md b/reference/algorithm/ranges_remove_if.md index 6ee0da6da1..b6c23a265f 100644 --- a/reference/algorithm/ranges_remove_if.md +++ b/reference/algorithm/ranges_remove_if.md @@ -24,9 +24,37 @@ namespace std::ranges { remove_if(R&& r, Pred pred, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + requires permutable + subrange + remove_if(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires permutable> + borrowed_subrange_t + remove_if(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -34,6 +62,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -59,6 +89,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -98,6 +129,35 @@ size before: 5 size after: 2 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // 並列に奇数を除去する + auto result = std::ranges::remove_if(std::execution::par, v, + [](int x) { return x % 2 != 0; }); + v.erase(result.begin(), result.end()); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::remove_if[color ff0000] +* v.erase[link /reference/vector/vector/erase.md] + +#### 出力 +``` +2 4 6 8 10 +``` + ## バージョン ### 言語 - C++20 @@ -110,3 +170,4 @@ size after: 2 ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_replace.md b/reference/algorithm/ranges_replace.md index 9e208283a8..26bc41e47c 100644 --- a/reference/algorithm/ranges_replace.md +++ b/reference/algorithm/ranges_replace.md @@ -71,16 +71,59 @@ namespace std::ranges { const T1& old_value, const T2& new_value, Proj proj = {}); // (2) C++26 + + template S, + class T1, + class T2, + class Proj = identity> + requires indirectly_writable && + indirect_binary_predicate< + ranges::equal_to, + projected, + const T1* + > + I replace(Ep&& exec, + I first, + S last, + const T1& old_value, + const T2& new_value, + Proj proj = {}); // (3) C++26 + + template + requires indirectly_writable, const T2&> && + indirect_binary_predicate< + ranges::equal_to, + projected, Proj>, + const T1* + > + borrowed_iterator_t + replace(Ep&& exec, + R&& r, + const T1& old_value, + const T2& new_value, + Proj proj = {}); // (4) C++26 } ``` * indirectly_writable[link /reference/iterator/indirectly_writable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値と一致する要素を指定された値に置き換える。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -168,6 +211,32 @@ int main() { 9,9 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 2, 5, 2, 7}; + + // 並列に値2を全て10に置き換える + std::ranges::replace(std::execution::par, v, 2, 10); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::replace[color ff0000] + +#### 出力 +``` +1 10 3 10 5 10 7 +``` + ## バージョン ### 言語 - C++20 @@ -182,3 +251,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_replace_copy.md b/reference/algorithm/ranges_replace_copy.md index 6fe9ba293d..03ffe9d920 100644 --- a/reference/algorithm/ranges_replace_copy.md +++ b/reference/algorithm/ranges_replace_copy.md @@ -24,7 +24,7 @@ namespace std::ranges { O result, const T1& old_value, const T2& new_value, - Proj proj = {}); // (1) C++20 + Proj proj = {}); // (1) C++20 template S, class O, @@ -43,7 +43,7 @@ namespace std::ranges { O result, const T1& old_value, const T2& new_value, - Proj proj = {}); // (1) C++26 + Proj proj = {}); // (1) C++26 template S, + random_access_iterator O, + sized_sentinel_for OutS, + class T1, + class T2, + class Proj = identity> + requires indirectly_copyable && + indirect_binary_predicate< + ranges::equal_to, + projected, + const T1* + > + replace_copy_result + replace_copy(Ep&& exec, + I first, + S last, + O result, + OutS result_last, + const T1& old_value, + const T2& new_value, + Proj proj = {}); // (3) C++26 + + template + requires indirectly_copyable, iterator_t> && + indirect_binary_predicate< + ranges::equal_to, + projected, Proj>, + const T1* + > + replace_copy_result, borrowed_iterator_t> + replace_copy(Ep&& exec, + R&& r, + OutR&& result_r, + const T1& old_value, + const T2& new_value, + Proj proj = {}); // (4) C++26 } ``` * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * replace_copy_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された値を一致する要素を指定された値に置き換え、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,last)` と `[result,result + (last - first))` の範囲が重なっていてはならない。 @@ -185,6 +235,34 @@ int main() { 9,9 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {3, 1, 2, 1, 2}; + std::vector dst(src.size()); + + // 並列に1を10に置き換えてコピー + std::ranges::replace_copy(std::execution::par, + src, dst, 1, 10); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::replace_copy[color ff0000] + +#### 出力 +``` +3 10 2 10 2 +``` + ## バージョン ### 言語 - C++20 @@ -199,3 +277,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_replace_copy_if.md b/reference/algorithm/ranges_replace_copy_if.md index ef97b244c7..6dd2ba5c44 100644 --- a/reference/algorithm/ranges_replace_copy_if.md +++ b/reference/algorithm/ranges_replace_copy_if.md @@ -19,7 +19,7 @@ namespace std::ranges { O result, Pred pred, const T& new_value, - Proj proj = {}); // (1) C++20 + Proj proj = {}); // (1) C++20 template S, class O, @@ -35,7 +35,7 @@ namespace std::ranges { O result, Pred pred, const T& new_value, - Proj proj = {}); // (1) C++26 + Proj proj = {}); // (1) C++26 template , @@ -62,18 +62,58 @@ namespace std::ranges { O result, Pred pred, const T& new_value, - Proj proj = {}); // (2) C++26 + Proj proj = {}); // (2) C++26 + + template S, + random_access_iterator O, + sized_sentinel_for OutS, + class T, + class Proj = identity, + indirect_unary_predicate> Pred> + requires indirectly_copyable + replace_copy_if_result + replace_copy_if(Ep&& exec, + I first, + S last, + O result, + OutS result_last, + Pred pred, + const T& new_value, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires indirectly_copyable, iterator_t> + replace_copy_if_result, borrowed_iterator_t> + replace_copy_if(Ep&& exec, + R&& r, + OutR&& result_r, + Pred pred, + const T& new_value, + Proj proj = {}); // (4) C++26 } ``` * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * replace_copy_if_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 条件を満たす要素を指定された値に置き換え、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,last)` と `[result,result + (last - first))` の範囲が重なっていてはならない。 @@ -172,6 +212,35 @@ int main() { 9,9 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {3, 1, 4, 1, 5}; + std::vector dst(src.size()); + + // 並列に奇数を0に置き換えてコピー + std::ranges::replace_copy_if(std::execution::par, + src, dst, + [](int x) { return x % 2 != 0; }, 0); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::replace_copy_if[color ff0000] + +#### 出力 +``` +0 0 4 0 0 +``` + ## バージョン ### 言語 - C++20 @@ -186,3 +255,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_replace_if.md b/reference/algorithm/ranges_replace_if.md index 21580be08c..6d8cd8f0dd 100644 --- a/reference/algorithm/ranges_replace_if.md +++ b/reference/algorithm/ranges_replace_if.md @@ -17,7 +17,7 @@ namespace std::ranges { S last, Pred pred, const T& new_value, - Proj proj = {}); // (1) C++20 + Proj proj = {}); // (1) C++20 template S, + class T, + class Proj = identity, + indirect_unary_predicate> Pred> + requires indirectly_writable + I replace_if(Ep&& exec, + I first, + S last, + Pred pred, + const T& new_value, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires indirectly_writable, const T&> + borrowed_iterator_t + replace_if(Ep&& exec, + R&& r, + Pred pred, + const T& new_value, + Proj proj = {}); // (4) C++26 } ``` * indirectly_writable[link /reference/iterator/indirectly_writable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 条件を満たす要素を指定された値に置き換える。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -64,6 +97,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -88,6 +122,33 @@ int main() { ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + + // 並列に奇数を全て0に置き換える + std::ranges::replace_if(std::execution::par, v, + [](int x) { return x % 2 != 0; }, 0); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::replace_if[color ff0000] + +#### 出力 +``` +0 2 0 4 0 6 0 8 0 10 +``` + ## バージョン ### 言語 - C++20 @@ -102,3 +163,4 @@ int main() { - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2248R8 Enabling list-initialization for algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2248r8.html) - C++26で波カッコ初期化 (リスト初期化) に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_reverse.md b/reference/algorithm/ranges_reverse.md index d144567a34..be480a16a2 100644 --- a/reference/algorithm/ranges_reverse.md +++ b/reference/algorithm/ranges_reverse.md @@ -17,16 +17,37 @@ namespace std::ranges { requires permutable> constexpr borrowed_iterator_t reverse(R&& r); // (2) C++20 + + template S> + requires permutable + I reverse(Ep&& exec, + I first, + S last); // (3) C++26 + + template + requires permutable> + borrowed_iterator_t + reverse(Ep&& exec, + R&& r); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 要素の並びを逆にする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -42,6 +63,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -62,6 +84,33 @@ esrever ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {1, 2, 3, 4, 5}; + + // 並列に要素の並びを逆にする + std::ranges::reverse(std::execution::par, v); + + for (int i : v) { + std::cout << i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::reverse[color ff0000] + +#### 出力 +``` +5 4 3 2 1 +``` + ## バージョン ### 言語 - C++20 @@ -74,3 +123,4 @@ esrever ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_reverse_copy.md b/reference/algorithm/ranges_reverse_copy.md index c0370b15d2..879d2d72e4 100644 --- a/reference/algorithm/ranges_reverse_copy.md +++ b/reference/algorithm/ranges_reverse_copy.md @@ -21,18 +21,47 @@ namespace std::ranges { constexpr reverse_copy_result, O> reverse_copy(R&& r, O result); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS> + requires indirectly_copyable + reverse_copy_truncated_result + reverse_copy(Ep&& exec, + I first, + S last, + O result, + OutS result_last); // (3) C++26 + + template + requires indirectly_copyable, iterator_t> + reverse_copy_truncated_result, borrowed_iterator_t> + reverse_copy(Ep&& exec, + R&& r, + OutR&& result_r); // (4) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * indirectly_copyable[link /reference/iterator/indirectly_copyable.md] * reverse_copy_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] +* reverse_copy_truncated_result[link ranges_in_in_out_result.md] ## 概要 要素の並びを逆にし、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -44,7 +73,8 @@ namespace std::ranges { ## 戻り値 -`{ .in = last, .out = result + (last - first) }` +- (1), (2): `{ .in = last, .out = result + (last - first) }` +- (3), (4): 出力範囲が入力範囲より短い場合、出力範囲の末尾まで書き込み、`in1`と`in2`で入力範囲のどこまで処理されたかを示す。`in1`は常に`last`と等しく、`in2`は入力範囲内の停止点を指す。出力範囲が十分な場合は`in2 == first`となる ## 計算量 @@ -52,6 +82,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -66,11 +97,38 @@ int main() { ``` * std::ranges::reverse_copy[color ff0000] -### 出力 +#### 出力 ``` esrever ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5}; + std::vector dst(src.size()); + + // 並列に逆順コピーする + auto result = std::ranges::reverse_copy(std::execution::par, src, dst); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::reverse_copy[color ff0000] + +#### 出力 +``` +5 4 3 2 1 +``` + ## バージョン ### 言語 @@ -84,3 +142,5 @@ esrever ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) +- [P3709R2 Reconsider parallel `ranges::rotate_copy` and `ranges::reverse_copy`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3709r2.html) diff --git a/reference/algorithm/ranges_rotate.md b/reference/algorithm/ranges_rotate.md index a72fe1ebba..23a4eb07d5 100644 --- a/reference/algorithm/ranges_rotate.md +++ b/reference/algorithm/ranges_rotate.md @@ -18,15 +18,39 @@ namespace std::ranges { constexpr borrowed_subrange_t rotate(R&& r, iterator_t middle); // (2) C++20 + + template S> + requires permutable + subrange + rotate(Ep&& exec, + I first, + I middle, + S last); // (3) C++26 + + template + requires permutable> + borrowed_subrange_t + rotate(Ep&& exec, + R&& r, + iterator_t middle); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 `middle`の要素が先頭、`middle-1`の要素が末尾となるように、`[first,last)`の要素の並びを回転させる。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,middle)` と `[middle,last)` は有効な範囲である必要がある。 @@ -131,6 +155,34 @@ swapping 0x1806043(1) <-> 0x1806045(5) 234501 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {1, 2, 3, 4, 5}; + + // 並列に要素を回転させる (先頭から2つ目の要素が先頭に来る) + std::ranges::rotate(std::execution::par, v, v.begin() + 2); + + for (int i : v) { + std::cout << i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::rotate[color ff0000] +* v.begin()[link /reference/vector/vector/begin.md] + +#### 出力 +``` +3 4 5 1 2 +``` + ## 実装例 - [std::rotate を読んでみた](http://www.kmonos.net/wlog/115.html#_0007101223) @@ -146,3 +198,4 @@ swapping 0x1806043(1) <-> 0x1806045(5) ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_rotate_copy.md b/reference/algorithm/ranges_rotate_copy.md index 6e2aa01a10..67725ea133 100644 --- a/reference/algorithm/ranges_rotate_copy.md +++ b/reference/algorithm/ranges_rotate_copy.md @@ -23,17 +23,48 @@ namespace std::ranges { rotate_copy(R&& r, iterator_t middle, O result); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS> + requires indirectly_copyable + rotate_copy_truncated_result + rotate_copy(Ep&& exec, + I first, + I middle, + S last, + O result, + OutS result_last); // (3) C++26 + + template + requires indirectly_copyable, iterator_t> + rotate_copy_truncated_result, borrowed_iterator_t> + rotate_copy(Ep&& exec, + R&& r, + iterator_t middle, + OutR&& result_r); // (4) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] * rotate_copy_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] +* rotate_copy_truncated_result[link ranges_in_in_out_result.md] ## 概要 `middle`の要素が先頭、`middle-1`の要素が末尾となるように、`[first,last)`の要素の並びを回転させ、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定し、出力範囲の終端も指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -45,7 +76,8 @@ namespace std::ranges { ## 戻り値 -回転前の先頭の要素を指すイテレータ`result + (last - first)` +- (1), (2): `{ .in = last, .out = result + (last - first) }` +- (3), (4): 出力範囲が入力範囲より短い場合、出力範囲の末尾まで書き込み、`in1`と`in2`で入力範囲のどこまで処理されたかを示す。`in1`は`[middle, last)`の範囲内の停止点、`in2`は`[first, middle)`の範囲内の停止点を指す。出力範囲が十分な場合は`in1 == last`かつ`in2 == middle`となる ## 計算量 @@ -53,6 +85,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -71,11 +104,39 @@ int main() { * std::ranges::rotate_copy[color ff0000] * str.begin()[link /reference/string/basic_string/begin.md] -### 出力 +#### 出力 ``` tatero ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5}; + std::vector dst(src.size()); + + // 並列に回転コピーする（3番目の要素が先頭になるように） + auto result = std::ranges::rotate_copy( + std::execution::par, src, src.begin() + 2, dst); + + for (int x : dst) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::rotate_copy[color ff0000] + +#### 出力 +``` +3 4 5 1 2 +``` + ## バージョン ### 言語 - C++20 @@ -88,3 +149,5 @@ tatero ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) +- [P3709R2 Reconsider parallel `ranges::rotate_copy` and `ranges::reverse_copy`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3709r2.html) diff --git a/reference/algorithm/ranges_search.md b/reference/algorithm/ranges_search.md index 4ff7e480eb..ef8d610055 100644 --- a/reference/algorithm/ranges_search.md +++ b/reference/algorithm/ranges_search.md @@ -35,14 +35,54 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + subrange + search(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + borrowed_subrange_t + search(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 あるシーケンスの中から、特定のサブシーケンスを探す - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 - (1) : @@ -54,6 +94,7 @@ namespace std::ranges { 最大で `(last1 - first1) * (last2 - first2)` 回の、対応する比較もしくは述語が適用される ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -83,6 +124,33 @@ found: index==0 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5, 3, 4}; + std::vector pattern = {3, 4}; + + // 並列にサブシーケンスを検索する + auto sr = std::ranges::search(std::execution::par, v, pattern); + if (sr.empty()) { + std::cout << "not found" << std::endl; + } else { + std::cout << "found: index==" << std::distance(v.begin(), sr.begin()) << std::endl; + } +} +``` +* std::ranges::search[color ff0000] + +#### 出力 +``` +found: index==2 +``` + ## 実装例 ```cpp struct search_impl { @@ -128,3 +196,4 @@ inline constexpr search_impl search; ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_set_difference.md b/reference/algorithm/ranges_set_difference.md index 3cf8ab2d23..30a8b7c9b8 100644 --- a/reference/algorithm/ranges_set_difference.md +++ b/reference/algorithm/ranges_set_difference.md @@ -39,6 +39,46 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + random_access_iterator O, + sized_sentinel_for OutS, + class Comp = ranges::less, + class Proj1 = identity, + class Proj2 = identity> + requires mergeable + set_difference_result + set_difference(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + O result, + OutS result_last, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires mergeable, iterator_t, iterator_t, Comp, Proj1, Proj2> + set_difference_result, borrowed_iterator_t> + set_difference(Ep&& exec, + R1&& r1, + R2&& r2, + OutR&& result_r, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * set_difference_result[link ranges_in_out_result.md] @@ -46,6 +86,10 @@ namespace std::ranges { * ranges::less[link /reference/functional/ranges_less.md] * mergeable[link /reference/iterator/mergeable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -53,6 +97,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 結果の範囲は両方の入力の範囲と重なっていてはならない。 @@ -83,6 +129,7 @@ set_difference_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -115,6 +162,40 @@ int main() 6 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector a = {1, 2, 3, 4, 5, 6}; + std::vector b = {2, 3, 4}; + std::vector result(a.size()); + + // 並列にa - bの差集合を作る + auto ret = std::ranges::set_difference( + std::execution::par, + a, + b, + result + ); + + for (auto it = result.begin(); it != ret.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::set_difference[color ff0000] + +#### 出力 +``` +1 5 6 +``` + ## バージョン ### 言語 - C++20 @@ -127,3 +208,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_set_intersection.md b/reference/algorithm/ranges_set_intersection.md index 6ae748e665..f349845a73 100644 --- a/reference/algorithm/ranges_set_intersection.md +++ b/reference/algorithm/ranges_set_intersection.md @@ -43,6 +43,50 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + random_access_iterator O, + sized_sentinel_for OutS, + class Comp = ranges::less, + class Proj1 = identity, + class Proj2 = identity> + requires mergeable + set_intersection_result + set_intersection(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + O result, + OutS result_last, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires mergeable, iterator_t, iterator_t, Comp, Proj1, Proj2> + set_intersection_result< + borrowed_iterator_t, + borrowed_iterator_t, + borrowed_iterator_t + > + set_intersection(Ep&& exec, + R1&& r1, + R2&& r2, + OutR&& result_r, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * set_intersection_result[link ranges_in_in_out_result.md] @@ -50,12 +94,18 @@ namespace std::ranges { * ranges::less[link /reference/functional/ranges_less.md] * mergeable[link /reference/iterator/mergeable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つのソート済み範囲の積集合を得る - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -89,6 +139,7 @@ set_intersection_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -119,6 +170,40 @@ int main() 4 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector a = {1, 2, 3, 4}; + std::vector b = {2, 4, 5, 6}; + std::vector result(std::min(a.size(), b.size())); + + // 並列にaとbの積集合を作る + auto ret = std::ranges::set_intersection( + std::execution::par, + a, + b, + result + ); + + for (auto it = result.begin(); it != ret.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::set_intersection[color ff0000] + +#### 出力 +``` +2 4 +``` + ## バージョン ### 言語 - C++20 @@ -131,3 +216,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_set_symmetric_difference.md b/reference/algorithm/ranges_set_symmetric_difference.md index b2c8fa3ce2..64836ea7ef 100644 --- a/reference/algorithm/ranges_set_symmetric_difference.md +++ b/reference/algorithm/ranges_set_symmetric_difference.md @@ -43,6 +43,50 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + random_access_iterator O, + sized_sentinel_for OutS, + class Comp = ranges::less, + class Proj1 = identity, + class Proj2 = identity> + requires mergeable + set_symmetric_difference_result + set_symmetric_difference(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + O result, + OutS result_last, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires mergeable, iterator_t, iterator_t, Comp, Proj1, Proj2> + set_symmetric_difference_result< + borrowed_iterator_t, + borrowed_iterator_t, + borrowed_iterator_t + > + set_symmetric_difference(Ep&& exec, + R1&& r1, + R2&& r2, + OutR&& result_r, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * set_symmetric_difference_result[link ranges_in_in_out_result.md] @@ -50,12 +94,18 @@ namespace std::ranges { * ranges::less[link /reference/functional/ranges_less.md] * mergeable[link /reference/iterator/mergeable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つのソート済み範囲の対称差集合、すなわち2つの範囲の共通しない要素からなる集合を得る。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 @@ -91,6 +141,7 @@ set_symmetric_difference_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -116,7 +167,7 @@ int main() * end()[link /reference/set/set/end.md] * std::inserter[link /reference/iterator/inserter.md] -### 出力 +#### 出力 ``` 1 5 @@ -125,6 +176,39 @@ int main() 8 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector a = {1, 2, 3, 4, 5}; + std::vector b = {2, 4, 6, 8}; + std::vector result(a.size() + b.size()); + + // 並列に対称差を求める + auto [in1, in2, out] = std::ranges::set_symmetric_difference( + std::execution::par, + a, + b, + result + ); + + for (auto it = result.begin(); it != out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::set_symmetric_difference[color ff0000] + +#### 出力 +``` +1 3 5 6 8 +``` + ## バージョン ### 言語 - C++20 @@ -137,3 +221,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_set_union.md b/reference/algorithm/ranges_set_union.md index e4f8a977f4..e650cf4902 100644 --- a/reference/algorithm/ranges_set_union.md +++ b/reference/algorithm/ranges_set_union.md @@ -45,6 +45,52 @@ namespace std::ranges { Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + random_access_iterator O, + sized_sentinel_for OutS, + class Comp = ranges::less, + class Proj1 = identity, + class Proj2 = identity> + requires mergeable + set_union_result + set_union(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + O result, + OutS result_last, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires mergeable< + iterator_t, + iterator_t, + iterator_t, + Comp, + Proj1, + Proj2> + set_union_result, borrowed_iterator_t, borrowed_iterator_t> + set_union(Ep&& exec, + R1&& r1, + R2&& r2, + OutR&& result_r, + Comp comp = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` * set_union_result[link ranges_in_in_out_result.md] @@ -52,12 +98,18 @@ namespace std::ranges { * ranges::less[link /reference/functional/ranges_less.md] * mergeable[link /reference/iterator/mergeable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 2つのソート済み範囲の和集合を得る - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 結果の範囲は両方の入力の範囲と重なっていてはならない。 @@ -83,6 +135,7 @@ set_union_result { 最大で `2 * ((last1 - first1) + (last2 - first2)) - 1` 回の比較を行う ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -121,6 +174,40 @@ int main() 6 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector a = {1, 2, 3, 4}; + std::vector b = {2, 4, 5, 6}; + std::vector result(a.size() + b.size()); + + // 並列にaとbの和集合を作る + auto ret = std::ranges::set_union( + std::execution::par, + a, + b, + result + ); + + for (auto it = result.begin(); it != ret.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::set_union[color ff0000] + +#### 出力 +``` +1 2 3 4 5 6 +``` + ## バージョン ### 言語 - C++20 @@ -133,3 +220,4 @@ int main() ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_shift_left.md b/reference/algorithm/ranges_shift_left.md index 73310893b3..712f3cdbc0 100644 --- a/reference/algorithm/ranges_shift_left.md +++ b/reference/algorithm/ranges_shift_left.md @@ -18,15 +18,39 @@ namespace std::ranges { constexpr borrowed_subrange_t shift_left(R&& r, range_difference_t n); // (2) C++23 + + template S> + requires permutable + subrange + shift_left(Ep&& exec, + I first, + S last, + iter_difference_t n); // (3) C++26 + + template + requires permutable> + borrowed_subrange_t + shift_left(Ep&& exec, + R&& r, + range_difference_t n); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲の要素をn個だけ左にシフトさせる。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する この関数に符号付き整数型のシフト数として、0および負数を指定した場合はなにもしない。 @@ -62,6 +86,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -86,6 +111,32 @@ int main() 3,4,5,4,5, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5}; + + // 並列に2つ左シフト + auto result = std::ranges::shift_left(std::execution::par, v, 2); + + for (int x : result) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::shift_left[color ff0000] + +#### 出力 +``` +3 4 5 +``` + ## バージョン ### 言語 - C++23 @@ -98,3 +149,4 @@ int main() ## 参照 - [N4901 25 Algorithms library](https://timsong-cpp.github.io/cppwp/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_shift_right.md b/reference/algorithm/ranges_shift_right.md index 1d90e77d20..ca8d29d5d6 100644 --- a/reference/algorithm/ranges_shift_right.md +++ b/reference/algorithm/ranges_shift_right.md @@ -18,9 +18,31 @@ namespace std::ranges { constexpr borrowed_subrange_t shift_right(R&& r, range_difference_t n); // (2) C++23 + + template S> + requires permutable + subrange + shift_right(Ep&& exec, + I first, + S last, + iter_difference_t n); // (3) C++26 + + template + requires permutable> + borrowed_subrange_t + shift_right(Ep&& exec, + R&& r, + range_difference_t n); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -28,6 +50,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する この関数に符号付き整数型のシフト数として、0および負数を指定した場合はなにもしない。 @@ -63,6 +87,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -87,6 +112,32 @@ int main() 1,2,1,2,3, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5}; + + // 並列に2つ右シフト + auto result = std::ranges::shift_right(std::execution::par, v, 2); + + for (int x : result) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::shift_right[color ff0000] + +#### 出力 +``` +1 2 3 +``` + ## バージョン ### 言語 - C++23 @@ -99,3 +150,4 @@ int main() ## 参照 - [N4901 25 Algorithms library](https://timsong-cpp.github.io/cppwp/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_sort.md b/reference/algorithm/ranges_sort.md index 95bb2f9017..3fd99752cc 100644 --- a/reference/algorithm/ranges_sort.md +++ b/reference/algorithm/ranges_sort.md @@ -25,17 +25,45 @@ namespace std::ranges { sort(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Comp = ranges::less, + class Proj = identity> + requires sortable + I sort(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template + requires sortable, Comp, Proj> + borrowed_iterator_t + sort(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * sortable[link /reference/iterator/sortable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲を並べ替える - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 `[first,last)` の範囲をソートする @@ -164,6 +192,33 @@ Carol Bob ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}; + + // 並列ソート + std::ranges::sort(std::execution::par, v); + + for (int i : v) { + std::cout << i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::sort[color ff0000] + +#### 出力 +``` +1 1 2 3 3 4 5 5 5 6 9 +``` + ## バージョン ### 言語 - C++20 @@ -176,3 +231,4 @@ Bob ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_stable_partition.md b/reference/algorithm/ranges_stable_partition.md index 872f5f7cc8..e425a0e815 100644 --- a/reference/algorithm/ranges_stable_partition.md +++ b/reference/algorithm/ranges_stable_partition.md @@ -43,9 +43,37 @@ namespace std::ranges { stable_partition(R&& r, Pred pred, Proj proj = {}); // (2) C++26 + + template S, + class Proj = identity, + indirect_unary_predicate> Pred> + requires permutable + subrange + stable_partition(Ep&& exec, + I first, + S last, + Pred pred, + Proj proj = {}); // (3) C++26 + + template , Proj>> Pred> + requires permutable> + borrowed_subrange_t + stable_partition(Ep&& exec, + R&& r, + Pred pred, + Proj proj = {}); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -53,6 +81,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -74,6 +104,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -102,6 +133,33 @@ int main() 5 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {1, 2, 3, 4, 5, 6, 7, 8}; + + // 並列に相対順序を保ちながら偶数グループと奇数グループに分ける + std::ranges::stable_partition(std::execution::par, v, [](int x) { return x % 2 == 0; }); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::stable_partition[color ff0000] + +#### 出力 +``` +2 4 6 8 1 3 5 7 +``` + ## バージョン ### 言語 - C++20 @@ -116,3 +174,4 @@ int main() - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2562R1 `constexpr` Stable Sorting](https://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2562r1.pdf) - C++26から`constexpr`に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_stable_sort.md b/reference/algorithm/ranges_stable_sort.md index 8497fd89e3..94f35b9ca8 100644 --- a/reference/algorithm/ranges_stable_sort.md +++ b/reference/algorithm/ranges_stable_sort.md @@ -43,17 +43,45 @@ namespace std::ranges { stable_sort(R&& r, Comp comp = {}, Proj proj = {}); // (2) C++26 + + template S, + class Comp = ranges::less, + class Proj = identity> + requires sortable + I stable_sort(Ep&& exec, + I first, + S last, + Comp comp = {}, + Proj proj = {}); // (3) C++26 + + template + requires sortable, Comp, Proj> + borrowed_iterator_t + stable_sort(Ep&& exec, + R&& r, + Comp comp = {}, + Proj proj = {}); // (4) C++26 } ``` * ranges::less[link /reference/functional/ranges_less.md] * sortable[link /reference/iterator/sortable.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 範囲を安定ソートで並べ替える - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 `[first,last)` の範囲をソートする @@ -72,6 +100,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -97,6 +126,33 @@ int main() 12345 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() +{ + std::vector v = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}; + + // 並列に安定ソートする + std::ranges::stable_sort(std::execution::par, v); + + for (int i : v) { + std::cout << i << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::stable_sort[color ff0000] + +#### 出力 +``` +1 1 2 3 3 4 5 5 5 6 9 +``` + ## バージョン ### 言語 - C++20 @@ -111,3 +167,4 @@ int main() - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) - [P2562R1 `constexpr` Stable Sorting](https://open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2562r1.pdf) - C++26から`constexpr`に対応した +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_starts_with.md b/reference/algorithm/ranges_starts_with.md index a3e605434e..d7ee0b1c02 100644 --- a/reference/algorithm/ranges_starts_with.md +++ b/reference/algorithm/ranges_starts_with.md @@ -35,8 +35,46 @@ namespace std::ranges { Pred pred = {}, Proj1 proj1 = {}, Proj2 proj2 = {}); // (2) C++23 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + class Pred = ranges::equal_to, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_comparable + bool + starts_with(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (3) C++26 + + template + requires indirectly_comparable, iterator_t, Pred, Proj1, Proj2> + bool + starts_with(Ep&& exec, + R1&& r1, + R2&& r2, + Pred pred = {}, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (4) C++26 } ``` +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -44,6 +82,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 戻り値 @@ -54,6 +94,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -70,13 +111,38 @@ int main() { ``` * std::ranges::starts_with[color ff0000] -### 出力 +#### 出力 ``` 1 0 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5, 6}; + std::vector prefix = {1, 2, 3}; + + std::cout << std::boolalpha; + + // 並列に先頭が一致するかを判定 + bool result = std::ranges::starts_with(std::execution::par, v, prefix); + std::cout << result << std::endl; +} +``` +* std::ranges::starts_with[color ff0000] + +#### 出力 +``` +true +``` + ## 実装例 ```cpp struct starts_with_impl { @@ -114,3 +180,4 @@ inline constexpr starts_with_impl starts_with; ## 参照 - [N4950 27 Algorithms library](https://timsong-cpp.github.io/cppwp/n4950/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_swap_ranges.md b/reference/algorithm/ranges_swap_ranges.md index eca99ff9a9..d851f7e21e 100644 --- a/reference/algorithm/ranges_swap_ranges.md +++ b/reference/algorithm/ranges_swap_ranges.md @@ -15,7 +15,7 @@ namespace std::ranges { swap_ranges(I1 first1, S1 last1, I2 first2, - S2 last2); // (1) C++20 + S2 last2); // (1) C++20 template @@ -24,17 +24,47 @@ namespace std::ranges { borrowed_iterator_t, borrowed_iterator_t> swap_ranges(R1&& r1, - R2&& r2); // (2) C++20 + R2&& r2); // (2) C++20 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2> + requires indirectly_swappable + swap_ranges_result + swap_ranges(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2); // (3) C++26 + + template + requires indirectly_swappable, iterator_t> + swap_ranges_result< + borrowed_iterator_t, + borrowed_iterator_t> + swap_ranges(Ep&& exec, + R1&& r1, + R2&& r2); // (4) C++26 } ``` * swap_ranges_result[link ranges_in_in_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 指定された2つの範囲同士を swap する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 効果 @@ -63,6 +93,7 @@ swap_ranges_result { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -93,6 +124,41 @@ v1: 5,2,4, v2: 3,1,2,1,3, ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v1 = {1, 2, 3, 4, 5}; + std::vector v2 = {6, 7, 8, 9, 10}; + + // 並列に2つの範囲をswapする + std::ranges::swap_ranges(std::execution::par, v1, v2); + + std::cout << "v1: "; + for (int x : v1) { + std::cout << x << ' '; + } + std::cout << std::endl; + + std::cout << "v2: "; + for (int x : v2) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::swap_ranges[color ff0000] + +#### 出力 +``` +v1: 6 7 8 9 10 +v2: 1 2 3 4 5 +``` + ## バージョン ### 言語 - C++20 @@ -105,3 +171,4 @@ v2: 3,1,2,1,3, ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_transform.md b/reference/algorithm/ranges_transform.md index 6650810acb..dabb5817b4 100644 --- a/reference/algorithm/ranges_transform.md +++ b/reference/algorithm/ranges_transform.md @@ -80,6 +80,93 @@ namespace std::ranges { F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}); // (4) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS, + copy_constructible F, + class Proj = identity> + requires indirectly_writable< + O, + indirect_result_t> + > + unary_transform_result + transform(Ep&& exec, + I first1, + S last1, + O result, + OutS result_last, + F op, + Proj proj = {}); // (5) C++26 + + template + requires indirectly_writable< + iterator_t, + indirect_result_t, Proj>> + > + unary_transform_result, borrowed_iterator_t> + transform(Ep&& exec, + R&& r, + OutR&& result_r, + F op, + Proj proj = {}); // (6) C++26 + + template S1, + random_access_iterator I2, + sized_sentinel_for S2, + random_access_iterator O, + sized_sentinel_for OutS, + copy_constructible F, + class Proj1 = identity, + class Proj2 = identity> + requires indirectly_writable< + O, + indirect_result_t, projected> + > + binary_transform_result + transform(Ep&& exec, + I1 first1, + S1 last1, + I2 first2, + S2 last2, + O result, + OutS result_last, + F binary_op, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (7) C++26 + + template + requires indirectly_writable< + iterator_t, + indirect_result_t, Proj1>, + projected, Proj2>> + > + binary_transform_result< + borrowed_iterator_t, + borrowed_iterator_t, + borrowed_iterator_t + > + transform(Ep&& exec, + R1&& r1, + R2&& r2, + OutR&& result_r, + F binary_op, + Proj1 proj1 = {}, + Proj2 proj2 = {}); // (8) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] @@ -88,6 +175,10 @@ namespace std::ranges { * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] * unary_transform_result[link ranges_in_out_result.md] * binary_transform_result[link ranges_in_in_out_result.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -95,6 +186,8 @@ namespace std::ranges { - (1), (2): 1つの範囲の要素に関数を適用し、結果を出力イテレータに出力する - (3), (4): 2つの範囲の要素を1つずつ取り出して関数を適用し、結果を出力イテレータに出力する +- (5), (6): (1), (2)の並列アルゴリズム版。実行ポリシーを指定する +- (7), (8): (3), (4)の並列アルゴリズム版。実行ポリシーを指定する - (1), (3): イテレータ範囲を指定する - (2), (4): Rangeを直接指定する @@ -127,7 +220,8 @@ namespace std::ranges { - (3), (4) : `result` は `first1` や `first2` と同じであっても構わない。 -## (1)の例 +## 例 +### (1)の例 ```cpp example #include #include @@ -158,7 +252,7 @@ int main() { ``` -## (2)の例 +### (2)の例 ```cpp example #include #include @@ -188,6 +282,33 @@ b cccc ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 2, 3, 4, 5}; + std::vector result(v.size()); + + // 並列に全ての要素を2乗する + std::ranges::transform(std::execution::par, v, result, [](int x) { return x * x; }); + + for (int x : result) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::transform[color ff0000] + +#### 出力 +``` +1 4 9 16 25 +``` + ## バージョン ### 言語 - C++20 @@ -200,6 +321,7 @@ cccc ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) ## 関連項目 diff --git a/reference/algorithm/ranges_unique.md b/reference/algorithm/ranges_unique.md index 31f6880e65..04d0306714 100644 --- a/reference/algorithm/ranges_unique.md +++ b/reference/algorithm/ranges_unique.md @@ -24,10 +24,38 @@ namespace std::ranges { unique(R&& r, C comp = {}, Proj proj = {}); // (2) C++20 + + template S, + class Proj = identity, + indirect_equivalence_relation> C = ranges::equal_to> + requires permutable + subrange + unique(Ep&& exec, + I first, + S last, + C comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> C = ranges::equal_to> + requires permutable> + borrowed_subrange_t + unique(Ep&& exec, + R&& r, + C comp = {}, + Proj proj = {}); // (4) C++26 } ``` * permutable[link /reference/iterator/permutable.md] * indirect_equivalence_relation[link /reference/iterator/indirect_equivalence_relation.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 @@ -35,6 +63,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する この関数は、隣り合った重複要素を除いた要素を、範囲の先頭に集める。この関数によってコンテナから直接要素が削除され、コンテナの要素数が減るようなことはない。コンテナから実際に要素を削除する場合は、この関数の戻り値として、先頭に集められた重複なし範囲の末尾の次を指すイテレータが返るため、そのイテレータを介してコンテナの`erase()`メンバ関数などを呼び出し、削除を行うこと。 @@ -59,6 +89,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -118,6 +149,34 @@ unsorted unique : 2,5,3,1,2,4,2,1,4,3 sorted unique : 1,2,3,4,5 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector v = {1, 1, 2, 3, 3, 3, 4, 4, 5}; + + // 並列に隣り合った重複要素を除去する + auto result = std::ranges::unique(std::execution::par, v); + v.erase(result.begin(), result.end()); + + for (int x : v) { + std::cout << x << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::unique[color ff0000] +* v.erase[link /reference/vector/vector/erase.md] + +#### 出力 +``` +1 2 3 4 5 +``` + ## バージョン ### 言語 - C++20 @@ -130,3 +189,4 @@ sorted unique : 1,2,3,4,5 ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/algorithm/ranges_unique_copy.md b/reference/algorithm/ranges_unique_copy.md index eb7d537938..30c2fbe5e4 100644 --- a/reference/algorithm/ranges_unique_copy.md +++ b/reference/algorithm/ranges_unique_copy.md @@ -37,6 +37,36 @@ namespace std::ranges { O result, C comp = {}, Proj proj = {}); // (2) C++20 + + template S, + random_access_iterator O, + sized_sentinel_for OutS, + class Proj = identity, + indirect_equivalence_relation> C = ranges::equal_to> + requires indirectly_copyable + unique_copy_result + unique_copy(Ep&& exec, + I first, + S last, + O result, + OutS result_last, + C comp = {}, + Proj proj = {}); // (3) C++26 + + template , Proj>> C = ranges::equal_to> + requires indirectly_copyable, iterator_t> + unique_copy_result, borrowed_iterator_t> + unique_copy(Ep&& exec, + R&& r, + OutR&& result_r, + C comp = {}, + Proj proj = {}); // (4) C++26 } ``` * weakly_incrementable[link /reference/iterator/weakly_incrementable.md] @@ -45,12 +75,18 @@ namespace std::ranges { * indirectly_copyable_storable[link /reference/iterator/indirectly_copyable_storable.md] * unique_copy_result[link ranges_in_out_result.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 隣り合った重複要素を取り除き、その結果を出力の範囲へコピーする。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## 事前条件 - `[first,last)` と `[result,result + (last - first))` は重なっていてはならない @@ -73,6 +109,7 @@ namespace std::ranges { ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -129,6 +166,33 @@ unsorted unique : 2,5,3,1,2,4,2,1,4,3 sorted unique : 1,2,3,4,5 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 1, 2, 3, 3, 3, 4, 4, 5}; + std::vector dst(src.size()); + + // 並列に隣り合った重複要素を除去してコピーする + auto result = std::ranges::unique_copy(std::execution::par, src, dst); + + for (auto it = dst.begin(); it != result.out; ++it) { + std::cout << *it << ' '; + } + std::cout << std::endl; +} +``` +* std::ranges::unique_copy[color ff0000] + +#### 出力 +``` +1 2 3 4 5 +``` + ## バージョン ### 言語 - C++20 @@ -141,3 +205,4 @@ sorted unique : 1,2,3,4,5 ## 参照 - [N4861 25 Algorithms library](https://timsong-cpp.github.io/cppwp/n4861/algorithms) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/execution.md b/reference/execution.md index c4fe506ba3..c0434ef1dd 100644 --- a/reference/execution.md +++ b/reference/execution.md @@ -11,6 +11,7 @@ |------|------|----------------| | [`execution`](execution/execution.md) | 実行ポリシー用の名前空間 (namespace) | C++17 | | [`is_execution_policy`](execution/is_execution_policy.md) | 型が実行ポリシーかを判定する (class template) | C++17 | +| [`execution-policy`](execution/execution-policy.md) | 型が実行ポリシーであることを表す (説明専用concept) | C++26 | ## 実行制御ライブラリ(C++26) @@ -29,3 +30,4 @@ ## 参照 - [P0024R2 The Parallelism TS Should be Standardized](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0024r2.html) - [P2300R10 `std::execution`](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p2300r10.html) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/execution/execution-policy.md b/reference/execution/execution-policy.md new file mode 100644 index 0000000000..635cbc8f08 --- /dev/null +++ b/reference/execution/execution-policy.md @@ -0,0 +1,31 @@ +# execution-policy +* execution[meta header] +* concept[meta id-type] +* std[meta namespace] +* cpp26[meta cpp] + +```cpp +namespace std { + template + concept execution-policy = is_execution_policy_v>; +} +``` +* is_execution_policy_v[link is_execution_policy.md] +* remove_cvref_t[link /reference/type_traits/remove_cvref.md] + +## 概要 +`execution-policy`は、型`T`が実行ポリシー型であることを表す説明専用のコンセプトである。 + +このコンセプトは、並列Rangeアルゴリズムのテンプレートパラメータ制約として使用される。 + +このコンセプトに合致する型は、以下のページを参照： + +- [実行ポリシー](execution/execution_policy.md) + + +## バージョン +### 言語 +- C++26 + +## 参照 +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_destroy.md b/reference/memory/ranges_destroy.md index 075fcc299c..19d0f925d5 100644 --- a/reference/memory/ranges_destroy.md +++ b/reference/memory/ranges_destroy.md @@ -13,6 +13,17 @@ namespace std::ranges { template requires destructible> constexpr borrowed_iterator_t destroy(R&& r) noexcept; // (2) C++20 + + template S> + requires destructible> + I destroy(Ep&& exec, I first, S last) noexcept; // (3) C++26 + + template + requires destructible> + borrowed_iterator_t destroy(Ep&& exec, R&& r) noexcept; // (4) C++26 } ``` * no-throw-input-iterator[link no-throw-input-iterator.md] @@ -20,6 +31,10 @@ namespace std::ranges { * destructible[link /reference/concepts/destructible.md] * no-throw-input-range[link no-throw-input-range.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 デストラクタを呼び出す。 @@ -28,6 +43,8 @@ namespace std::ranges { - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -52,6 +69,7 @@ return first; ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -94,6 +112,35 @@ int main() 0 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::allocator alloc; + std::string* p = alloc.allocate(3); + + for (int i = 0; i < 3; ++i) { + std::construct_at(p + i, "hello"); + } + + // 並列に破棄 + std::ranges::destroy(std::execution::par, p, p + 3); + + alloc.deallocate(p, 3); + std::cout << "done" << std::endl; +} +``` +* std::ranges::destroy[color ff0000] + +#### 出力 +``` +done +``` + ## バージョン ### 言語 - C++20 @@ -109,3 +156,4 @@ int main() ## 参照 - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_destroy_n.md b/reference/memory/ranges_destroy_n.md index 258acf0e1d..3d6da8eae2 100644 --- a/reference/memory/ranges_destroy_n.md +++ b/reference/memory/ranges_destroy_n.md @@ -9,16 +9,26 @@ namespace std::ranges { template requires destructible> constexpr I destroy_n(I first, iter_difference_t n) noexcept; // (1) C++20 + + template + requires destructible> + I destroy_n(Ep&& exec, I first, iter_difference_t n) noexcept; // (2) C++26 } ``` * no-throw-input-iterator[link no-throw-input-iterator.md] * destructible[link /reference/concepts/destructible.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 イテレータ範囲`[first, first + n)`の各要素に対してデストラクタを呼び出す。 この関数は、配置`new`で構築したオブジェクトを破棄するために使用する。 +- (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する + ## テンプレートパラメータ制約 - (1): @@ -38,6 +48,7 @@ return destroy(counted_iterator(first, n), default_sentinel).base(); ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -80,6 +91,35 @@ int main() 0 ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::allocator alloc; + std::string* p = alloc.allocate(3); + + for (int i = 0; i < 3; ++i) { + std::construct_at(p + i, "hello"); + } + + // 並列にn個破棄 + std::ranges::destroy_n(std::execution::par, p, 3); + + alloc.deallocate(p, 3); + std::cout << "done" << std::endl; +} +``` +* std::ranges::destroy_n[color ff0000] + +#### 出力 +``` +done +``` + ## バージョン ### 言語 - C++20 @@ -95,3 +135,4 @@ int main() ## 参照 - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_copy.md b/reference/memory/ranges_uninitialized_copy.md index 7e76fade95..35100d93d1 100644 --- a/reference/memory/ranges_uninitialized_copy.md +++ b/reference/memory/ranges_uninitialized_copy.md @@ -42,6 +42,29 @@ namespace std::ranges { > uninitialized_copy(IR&& in_range, OR&& out_range); // (2) C++26 + + template S1, + random_access_iterator O, sized_sentinel_for S2> + requires constructible_from, iter_reference_t> + uninitialized_copy_result + uninitialized_copy(Ep&& exec, + I ifirst, + S1 ilast, + O ofirst, + S2 olast); // (3) C++26 + + template + requires constructible_from, range_reference_t> + uninitialized_copy_result< + borrowed_iterator_t, + borrowed_iterator_t + > + uninitialized_copy(Ep&& exec, + IR&& in_range, + OR&& out_range); // (4) C++26 } ``` * in_out_result[link /reference/algorithm/ranges_in_out_result.md] @@ -51,12 +74,18 @@ namespace std::ranges { * iter_reference_t[link /reference/iterator/iter_reference_t.md] * no-throw-forward-range[link no-throw-forward-range.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 -未初期化領域のイテレータ範囲（`out_range`、`[ofirst, olast)`）を配置`new`で入力イテレータ範囲（`in_range`、`[ifirst, ilast)`）の対応する要素から初期化してムーブ出力する。 +未初期化領域のイテレータ範囲（`out_range`、`[ofirst, olast)`）を配置`new`で入力イテレータ範囲（`in_range`、`[ifirst, ilast)`）の対応する要素から初期化してコピー出力する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -105,6 +134,7 @@ return {std::move(ifirst), ofirst}; ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -152,6 +182,39 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3}; + std::allocator alloc; + int* dst = alloc.allocate(3); + + // 並列に未初期化領域へコピー + std::ranges::uninitialized_copy( + std::execution::par, src, dst, dst + 3); + + for (int i = 0; i < 3; ++i) { + std::cout << dst[i] << ' '; + } + std::cout << std::endl; + + std::ranges::destroy(dst, dst + 3); + alloc.deallocate(dst, 3); +} +``` +* std::ranges::uninitialized_copy[color ff0000] + +#### 出力 +``` +1 2 3 +``` + + ## バージョン ### 言語 - C++20 @@ -169,3 +232,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_copy_n.md b/reference/memory/ranges_uninitialized_copy_n.md index fb409e56e4..52380f451e 100644 --- a/reference/memory/ranges_uninitialized_copy_n.md +++ b/reference/memory/ranges_uninitialized_copy_n.md @@ -31,6 +31,20 @@ namespace std::ranges { O ofirst, S olast ); // (1) C++26 + + template S> + requires constructible_from, iter_reference_t> + uninitialized_copy_n_result + uninitialized_copy_n( + Ep&& exec, + I ifirst, + iter_difference_t n, + O ofirst, + S olast + ); // (2) C++26 } ``` * in_out_result[link /reference/algorithm/ranges_in_out_result.md] @@ -38,11 +52,15 @@ namespace std::ranges { * no-throw-sentinel[link no-throw-sentinel.md] * constructible_from[link /reference/concepts/constructible_from.md] * iter_reference_t[link /reference/iterator/iter_reference_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] ## 概要 未初期化領域のイテレータ範囲`[ofirst, ofirst + n)`を配置`new`でイテレータ範囲`[ifirst, ifirst + n)`の対応する要素から初期化してコピー出力する。 - (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -77,6 +95,7 @@ return {std::move(t.in).base(), t.out}; ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -123,6 +142,39 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include + +int main() { + std::vector src = {1, 2, 3, 4, 5}; + std::allocator alloc; + int* dst = alloc.allocate(3); + + // 並列に3要素を未初期化領域へコピー + std::ranges::uninitialized_copy_n( + std::execution::par, src.begin(), 3, dst, dst + 3); + + for (int i = 0; i < 3; ++i) { + std::cout << dst[i] << ' '; + } + std::cout << std::endl; + + std::ranges::destroy(dst, dst + 3); + alloc.deallocate(dst, 3); +} +``` +* std::ranges::uninitialized_copy_n[color ff0000] + +#### 出力 +``` +1 2 3 +``` + + ## バージョン ### 言語 - C++20 @@ -140,3 +192,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_default_construct.md b/reference/memory/ranges_uninitialized_default_construct.md index 32812ee0c1..9e0669a5e5 100644 --- a/reference/memory/ranges_uninitialized_default_construct.md +++ b/reference/memory/ranges_uninitialized_default_construct.md @@ -23,18 +23,38 @@ namespace std::ranges { requires default_initializable> constexpr borrowed_iterator_t uninitialized_default_construct(R&& r); // (2) C++26 + + template S> + requires default_initializable> + I + uninitialized_default_construct(Ep&& exec, + I first, S last); // (3) C++26 + + template + requires default_initializable> + borrowed_iterator_t + uninitialized_default_construct(Ep&& exec, R&& r); // (4) C++26 } ``` * no-throw-forward-iterator[link no-throw-forward-iterator.md] * no-throw-sentinel[link no-throw-sentinel.md] * no-throw-forward-range[link no-throw-forward-range.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 未初期化領域の範囲 (`r`、`[first, last)`) の各要素をデフォルト構築する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -77,6 +97,7 @@ return first; ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -124,6 +145,32 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include + +int main() { + std::allocator alloc; + int* p = alloc.allocate(3); + + // 並列にデフォルト構築 + std::ranges::uninitialized_default_construct( + std::execution::par, p, p + 3); + + alloc.deallocate(p, 3); + std::cout << "done" << std::endl; +} +``` +* std::ranges::uninitialized_default_construct[color ff0000] + +#### 出力 +``` +done +``` + + ## バージョン ### 言語 - C++20 @@ -142,3 +189,4 @@ int main() - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - [P3369R0 `constexpr` for `uninitialized_default_construct`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3369r0.html) - 上記2文書で、C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_default_construct_n.md b/reference/memory/ranges_uninitialized_default_construct_n.md index 6e9cd283b4..f9ff6fdbc2 100644 --- a/reference/memory/ranges_uninitialized_default_construct_n.md +++ b/reference/memory/ranges_uninitialized_default_construct_n.md @@ -16,13 +16,26 @@ namespace std::ranges { constexpr I uninitialized_default_construct_n(I first, iter_difference_t n); // (1) C++26 + + template + requires default_initializable> + I + uninitialized_default_construct_n(Ep&& exec, + I first, + iter_difference_t n); // (2) C++26 } ``` * no-throw-forward-iterator[link no-throw-forward-iterator.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 未初期化領域の範囲 (`[first, first + n)`) の各要素をデフォルト構築する。 +- (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する + ## テンプレートパラメータ制約 - (1): @@ -46,6 +59,7 @@ return uninitialized_default_construct(counted_iterator(first, n), 呼び出すコンストラクタなどから例外が送出された場合、その例外がこの関数の外側に伝播される前に、その時点で構築済のオブジェクトは全て未規定の順序で破棄される。すなわち、例外が送出された場合は初期化対象領域は未初期化のままとなる。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -92,6 +106,32 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include + +int main() { + std::allocator alloc; + int* p = alloc.allocate(3); + + // 並列にn個デフォルト構築 + std::ranges::uninitialized_default_construct_n( + std::execution::par, p, 3); + + alloc.deallocate(p, 3); + std::cout << "done" << std::endl; +} +``` +* std::ranges::uninitialized_default_construct_n[color ff0000] + +#### 出力 +``` +done +``` + + ## バージョン ### 言語 - C++20 @@ -110,3 +150,4 @@ int main() - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - [P3369R0 `constexpr` for `uninitialized_default_construct`](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3369r0.html) - 上記2文書で、C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_fill.md b/reference/memory/ranges_uninitialized_fill.md index 735aa3dfac..4e2cd51e12 100644 --- a/reference/memory/ranges_uninitialized_fill.md +++ b/reference/memory/ranges_uninitialized_fill.md @@ -15,7 +15,8 @@ namespace std::ranges { no-throw-sentinel S, class T> requires constructible_from, const T&> - I uninitialized_fill(I first, S last, const T& x); // (1) C++26 + constexpr I + uninitialized_fill(I first, S last, const T& x); // (1) C++26 template @@ -27,6 +28,22 @@ namespace std::ranges { requires constructible_from, const T&> constexpr borrowed_iterator_t uninitialized_fill(R&& r, const T& x); // (2) C++26 + + template S, + class T> + requires constructible_from, const T&> + I uninitialized_fill(Ep&& exec, + I first, S last, const T& x); // (3) C++26 + + template + requires constructible_from, const T&> + borrowed_iterator_t + uninitialized_fill(Ep&& exec, + R&& r, const T& x); // (4) C++26 } ``` * no-throw-forward-iterator[link no-throw-forward-iterator.md] @@ -34,12 +51,18 @@ namespace std::ranges { * constructible_from[link /reference/concepts/constructible_from.md] * no-throw-forward-range[link no-throw-forward-range.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 未初期化領域の範囲 (`r`、`[first, last)`) を、指定された値で配置`new`で初期化する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -78,6 +101,7 @@ return first; 呼び出すコンストラクタなどから例外が送出された場合、その例外がこの関数の外側に伝播される前に、その時点で構築済のオブジェクトは全て未規定の順序で破棄される。すなわち、例外が送出された場合は初期化対象領域は未初期化のままとなる。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -121,6 +145,36 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include + +int main() { + std::allocator alloc; + int* p = alloc.allocate(3); + + // 並列に未初期化領域を42で埋める + std::ranges::uninitialized_fill( + std::execution::par, p, p + 3, 42); + + for (int i = 0; i < 3; ++i) { + std::cout << p[i] << ' '; + } + std::cout << std::endl; + + alloc.deallocate(p, 3); +} +``` +* std::ranges::uninitialized_fill[color ff0000] + +#### 出力 +``` +42 42 42 +``` + + ## バージョン ### 言語 - C++20 @@ -138,3 +192,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_fill_n.md b/reference/memory/ranges_uninitialized_fill_n.md index 5c03777726..c90ee2a521 100644 --- a/reference/memory/ranges_uninitialized_fill_n.md +++ b/reference/memory/ranges_uninitialized_fill_n.md @@ -18,14 +18,28 @@ namespace std::ranges { uninitialized_fill_n(I first, iter_difference_t n, const T& x); // (1) C++26 + + template + requires constructible_from, const T&> + I + uninitialized_fill_n(Ep&& exec, + I first, + iter_difference_t n, + const T& x); // (2) C++26 } ``` * no-throw-forward-iterator[link no-throw-forward-iterator.md] * constructible_from[link /reference/concepts/constructible_from.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 未初期化領域の範囲 (`[first, first + n)`) を、指定された値で配置`new`で初期化する。 +- (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する + ## テンプレートパラメータ制約 - (1): @@ -48,6 +62,7 @@ return uninitialized_fill(counted_iterator(first, n), default_sentinel, x).base( 呼び出すコンストラクタなどから例外が送出された場合、その例外がこの関数の外側に伝播される前に、その時点で構築済のオブジェクトは全て未規定の順序で破棄される。すなわち、例外が送出された場合は初期化対象領域は未初期化のままとなる。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -90,6 +105,36 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include + +int main() { + std::allocator alloc; + int* p = alloc.allocate(3); + + // 並列にn個の未初期化領域を99で埋める + std::ranges::uninitialized_fill_n( + std::execution::par, p, 3, 99); + + for (int i = 0; i < 3; ++i) { + std::cout << p[i] << ' '; + } + std::cout << std::endl; + + alloc.deallocate(p, 3); +} +``` +* std::ranges::uninitialized_fill_n[color ff0000] + +#### 出力 +``` +99 99 99 +``` + + ## バージョン ### 言語 - C++20 @@ -107,3 +152,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_move.md b/reference/memory/ranges_uninitialized_move.md index 2fca1ad0fe..2faf9699d7 100644 --- a/reference/memory/ranges_uninitialized_move.md +++ b/reference/memory/ranges_uninitialized_move.md @@ -34,6 +34,26 @@ namespace std::ranges { borrowed_iterator_t > uninitialized_move(IR&& in_range, OR&& out_range); // (2) C++26 + + template S1, + random_access_iterator O, sized_sentinel_for S2> + requires constructible_from, iter_rvalue_reference_t> + uninitialized_move_result + uninitialized_move(Ep&& exec, + I ifirst, S1 ilast, + O ofirst, S2 olast); // (3) C++26 + + template + requires constructible_from, range_rvalue_reference_t> + uninitialized_move_result< + borrowed_iterator_t, + borrowed_iterator_t + > + uninitialized_move(Ep&& exec, + IR&& in_range, OR&& out_range); // (4) C++26 } ``` * in_out_result[link /reference/algorithm/ranges_in_out_result.md] @@ -42,12 +62,18 @@ namespace std::ranges { * constructible_from[link /reference/concepts/constructible_from.md] * no-throw-forward-range[link no-throw-forward-range.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 未初期化領域の範囲（`out_range`、`[ofirst, olast)`）を配置`new`で入力範囲（`in_range`、`[ifirst, ilast)`）の対応する要素から初期化してムーブ出力する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -97,6 +123,7 @@ return {std::move(ifirst), ofirst}; またその場合、`[ifirst, ilast)`内の一部のオブジェクトは有効だが未規定な状態として残される。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -144,6 +171,40 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include +#include + +int main() { + std::vector src = {"hello", "world", "test"}; + std::allocator alloc; + std::string* dst = alloc.allocate(3); + + // 並列に未初期化領域へムーブ + std::ranges::uninitialized_move( + std::execution::par, src, dst, dst + 3); + + for (int i = 0; i < 3; ++i) { + std::cout << dst[i] << ' '; + } + std::cout << std::endl; + + std::ranges::destroy(dst, dst + 3); + alloc.deallocate(dst, 3); +} +``` +* std::ranges::uninitialized_move[color ff0000] + +#### 出力 +``` +hello world test +``` + + ## バージョン ### 言語 - C++20 @@ -161,3 +222,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_move_n.md b/reference/memory/ranges_uninitialized_move_n.md index 044b99e9f7..945884f492 100644 --- a/reference/memory/ranges_uninitialized_move_n.md +++ b/reference/memory/ranges_uninitialized_move_n.md @@ -31,17 +31,35 @@ namespace std::ranges { O ofirst, S olast ); // (1) C++26 + + template S> + requires constructible_from, iter_rvalue_reference_t> + uninitialized_move_n_result + uninitialized_move_n( + Ep&& exec, + I ifirst, + iter_difference_t n, + O ofirst, + S olast + ); // (2) C++26 } ``` * in_out_result[link /reference/algorithm/ranges_in_out_result.md] * no-throw-forward-iterator[link no-throw-forward-iterator.md] * no-throw-sentinel[link no-throw-sentinel.md] * constructible_from[link /reference/concepts/constructible_from.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] ## 概要 未初期化領域のイテレータ範囲`[ofirst, ofirst + n)`を配置`new`でイテレータ範囲`[ifirst, ifirst + n)`の対応する要素から初期化してムーブ出力する。 - (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -77,6 +95,7 @@ return {std::move(t.in).base(), t.out}; またその場合、`[ifirst, ifirst + n)`内の一部のオブジェクトは有効だが未規定な状態として残される。 ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -123,6 +142,40 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include +#include +#include + +int main() { + std::vector src = {"hello", "world", "test"}; + std::allocator alloc; + std::string* dst = alloc.allocate(3); + + // 並列に3要素を未初期化領域へムーブ + std::ranges::uninitialized_move_n( + std::execution::par, src.begin(), 3, dst, dst + 3); + + for (int i = 0; i < 3; ++i) { + std::cout << dst[i] << ' '; + } + std::cout << std::endl; + + std::ranges::destroy(dst, dst + 3); + alloc.deallocate(dst, 3); +} +``` +* std::ranges::uninitialized_move_n[color ff0000] + +#### 出力 +``` +hello world test +``` + + ## バージョン ### 言語 - C++20 @@ -140,3 +193,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_value_construct.md b/reference/memory/ranges_uninitialized_value_construct.md index 2e1d244235..587a6be874 100644 --- a/reference/memory/ranges_uninitialized_value_construct.md +++ b/reference/memory/ranges_uninitialized_value_construct.md @@ -23,18 +23,38 @@ namespace std::ranges { requires default_initializable> constexpr borrowed_iterator_t uninitialized_value_construct(R&& r); // (2) C++26 + + template S> + requires default_initializable> + I + uninitialized_value_construct(Ep&& exec, + I first, S last); // (3) C++26 + + template + requires default_initializable> + borrowed_iterator_t + uninitialized_value_construct(Ep&& exec, R&& r); // (4) C++26 } ``` * no-throw-forward-iterator[link no-throw-forward-iterator.md] * no-throw-sentinel[link no-throw-sentinel.md] * no-throw-forward-range[link no-throw-forward-range.md] * borrowed_iterator_t[link /reference/ranges/borrowed_iterator_t.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] +* sized_sentinel_for[link /reference/iterator/sized_sentinel_for.md] +* sized-random-access-range[link /reference/ranges/sized-random-access-range.md] ## 概要 未初期化領域の範囲 (`r`、`[first, last)`) の各要素を値構築する。 - (1): イテレータ範囲を指定する - (2): Rangeを直接指定する +- (3): (1)の並列アルゴリズム版。実行ポリシーを指定する +- (4): (2)の並列アルゴリズム版。実行ポリシーを指定する ## テンプレートパラメータ制約 @@ -73,6 +93,7 @@ return first; ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -120,6 +141,36 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include + +int main() { + std::allocator alloc; + int* p = alloc.allocate(3); + + // 並列に値初期化 + std::ranges::uninitialized_value_construct( + std::execution::par, p, p + 3); + + for (int i = 0; i < 3; ++i) { + std::cout << p[i] << ' '; + } + std::cout << std::endl; + + alloc.deallocate(p, 3); +} +``` +* std::ranges::uninitialized_value_construct[color ff0000] + +#### 出力 +``` +0 0 0 +``` + + ## バージョン ### 言語 - C++20 @@ -137,3 +188,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/memory/ranges_uninitialized_value_construct_n.md b/reference/memory/ranges_uninitialized_value_construct_n.md index be08059256..03103a277b 100644 --- a/reference/memory/ranges_uninitialized_value_construct_n.md +++ b/reference/memory/ranges_uninitialized_value_construct_n.md @@ -16,13 +16,26 @@ namespace std::ranges { constexpr I uninitialized_value_construct_n(I first, iter_difference_t n); // (1) C++26 + + template + requires default_initializable> + I + uninitialized_value_construct_n(Ep&& exec, + I first, + iter_difference_t n); // (2) C++26 } ``` * no-throw-forward-iterator[link no-throw-forward-iterator.md] +* execution-policy[link /reference/execution/execution-policy.md] +* random_access_iterator[link /reference/iterator/random_access_iterator.md] ## 概要 未初期化領域の範囲 (`[first, first + n)`) の各要素を値構築する。 +- (1): イテレータ範囲を指定する +- (2): (1)の並列アルゴリズム版。実行ポリシーを指定する + ## テンプレートパラメータ制約 - (1): @@ -47,6 +60,7 @@ return uninitialized_value_construct(counted_iterator(first, n), ## 例 +### 基本的な使い方 ```cpp example #include #include @@ -93,6 +107,36 @@ int main() ``` +### 並列アルゴリズムの例 (C++26) +```cpp example +#include +#include +#include + +int main() { + std::allocator alloc; + int* p = alloc.allocate(3); + + // 並列にn個値初期化 + std::ranges::uninitialized_value_construct_n( + std::execution::par, p, 3); + + for (int i = 0; i < 3; ++i) { + std::cout << p[i] << ' '; + } + std::cout << std::endl; + + alloc.deallocate(p, 3); +} +``` +* std::ranges::uninitialized_value_construct_n[color ff0000] + +#### 出力 +``` +0 0 0 +``` + + ## バージョン ### 言語 - C++20 @@ -110,3 +154,4 @@ int main() - [P0896R4 The One Ranges Proposal](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0896r4.pdf) - [P3508R0 Wording for "constexpr for specialized memory algorithms"](https://open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3508r0.html) - C++26から`constexpr`がついた +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html) diff --git a/reference/ranges.md b/reference/ranges.md index 6956f1b61c..395b20031a 100644 --- a/reference/ranges.md +++ b/reference/ranges.md @@ -91,6 +91,7 @@ C++20では関数によるカスタマイゼーションポイントの問題点 | [`common_range`](ranges/common_range.md) | イテレータと番兵の型が等しいRange (concept) | C++20 | | [`viewable_range`](ranges/viewable_range.md) | ビューに変換できるRange (concept) | C++20 | | [`constant_range`](ranges/constant_range.md) | 要素が定数なRange (concept) | C++23 | +| [`sized-random-access-range`](ranges/sized-random-access-range.md) | サイズ付きランダムアクセスRange (説明専用concept) | C++26 | ## カスタマイゼーションポイント diff --git a/reference/ranges/sized-random-access-range.md b/reference/ranges/sized-random-access-range.md new file mode 100644 index 0000000000..c6b5e78a65 --- /dev/null +++ b/reference/ranges/sized-random-access-range.md @@ -0,0 +1,27 @@ +# sized-random-access-range +* ranges[meta header] +* concept[meta id-type] +* std::ranges[meta namespace] +* cpp26[meta cpp] + +```cpp +namespace std::ranges { + template + concept sized-random-access-range = + random_access_range && sized_range; +} +``` +* random_access_range[link random_access_range.md] +* sized_range[link sized_range.md] + +## 概要 +`sized-random-access-range`は、範囲`R`が[`random_access_range`](random_access_range.md)かつ[`sized_range`](sized_range.md)であることを表す説明専用のコンセプトである。 + +このコンセプトは、並列Rangeアルゴリズムのテンプレートパラメータ制約として使用される。並列アルゴリズムでは、範囲のサイズが既知であり、かつランダムアクセスが可能である必要がある。 + +## バージョン +### 言語 +- C++26 + +## 参照 +- [P3179R9 C++ parallel range algorithms](https://open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3179r9.html)