std::ranges::for_each, std::ranges::for_each_result
ja.cppreference.net より
| (C++23) <algorithm>
|
||
| ヘッダ |
||
template< std::input_iterator I, std::sentinel_for<I> S,
class Proj = std::identity,
std::indirectly_unary_invocable<std::projected<I, Proj>> Fun >
constexpr for_each_result<I, Fun>
for_each( I first, S last, Fun f, Proj proj = {} );
|
で定義 | 呼び出しシグネチャ |
template< ranges::input_range R, class Proj = std::identity,
std::indirectly_unary_invocable
<std::projected<ranges::iterator_t<R>, Proj>> Fun >
constexpr for_each_result<ranges::borrowed_iterator_t<R>, Fun>
for_each( R&& r, Fun f, Proj proj = {} );
|
(1) | (C++20以上) |
template< /*execution-policy*/ Ep, std::random_access_iterator I,
std::sized_sentinel_for<I> S, class Proj = std::identity,
std::indirectly_unary_invocable<std::projected<I, Proj>> Fun >
I for_each( Ep&& policy, I first, S last, Fun f, Proj proj = {} );
|
(2) | (C++20以上) |
template< /*execution-policy*/ Ep,
/*sized-random-access-range*/ R, class Proj = std::identity,
std::indirectly_unary_invocable
<std::projected<ranges::iterator_t<R>, Proj>> Fun >
ranges::borrowed_iterator_t<R>
for_each( Ep&& policy, R&& r, Fun f, Proj proj = {} );
|
(3) | (C++26以上) |
| (4) |
||
template< class I, class F >
using for_each_result = ranges::in_fun_result<I, F>;
|
(C++26以上) | ヘルパー型 |
(5) /*execution-policy*/(C++20以上)の定義については、このページ/*sized-random-access-range*/を参照してください。の定義については、このページ
を参照してください。
f指定された呼び出し可能オブジェクト proj を、対象範囲 [first, last) または r の各要素（f によって射影された要素）に適用します。
が結果を返す場合、その結果は無視されます。
f1,2) は対象範囲の先頭から順に適用されます。
f3,4)policy は順序通りに適用されない可能性があります。アルゴリズムは に従って実行されます。 他の並列アルゴリズム
for_eachとは異なり、は対象範囲の要素の任意のコピーを作成することが許可されていません。このページで説明されている関数のようなエンティティは、アルゴリズム関数オブジェクト（通称 niebloid
- ）です。すなわち:
- それらのいずれかを呼び出す際に、明示的なテンプレート引数リストを指定することはできません。それらは引数依存の名前検索
- には表示されません。通常の非修飾名検索によって関数呼び出し演算子の左側の名前として見つかった場合、引数依存の名前検索は抑制されます。
パラメータ
| first, last | - | ターゲットの範囲 |
| r | - | ターゲット範囲 |
| f | - | （射影された）要素に適用される呼び出し可能オブジェクト |
| proj | - | 要素に適用される射影 |
| policy | - | 実行ポリシーを使用する |
戻り値
1)
{last, std::move(f)}2)
{ranges::next(ranges::begin(r), ranges::end(r)), std::move(f)} の場合 R は forward_rangeをモデルとする場合は、そうでなければ (C++26から){ranges::end(r), std::move(f)}3)
last4)
ranges::next(ranges::begin(r), ranges::end(r)) の場合 R は forward_rangeをモデルとする場合は、そうでなければ (C++26から)ranges::end(r)計算量
1,3) 正確に
ranges::distance(first, last) の適用 f および proj。2,4) 正確に
ranges::distance(r) の適用 f および proj。例外
3,4) 実行プロセス中:
- 並列化に必要な一時的なメモリリソースが利用できない場合、std::bad_alloc がスローされます。
- アルゴリズム引数を介してオブジェクトにアクセス中にキャッチされない例外がスローされた場合、動作は実行ポリシーによって決まります（標準ポリシーの場合、std::terminate が呼び出されます）。
注記
射影が変更可能な参照を返す場合、f はターゲット範囲の要素を変更しても構いません。
オーバーロード (1,2) の場合、f は状態を持つ呼び出し可能オブジェクトにできます。戻り値内の呼び出し可能オブジェクトは、バッチ操作の最終状態とみなせます。
オーバーロード (3,4) の場合、並列呼び出しを実行するために f の複数のコピーが作成される可能性があります。並列化では効率的な状態の蓄積が許されないことが多いため、戻り値には呼び出し可能オブジェクトは含まれません。
可能な実装
struct for_each_fn
{
template<std::input_iterator I, std::sentinel_for<I> S, class Proj = std::identity,
std::indirectly_unary_invocable<std::projected<I, Proj>> Fun>
constexpr ranges::for_each_result<I, Fun>
operator()(I first, S last, Fun f, Proj proj = {}) const
{
for (; first != last; ++first)
std::invoke(f, std::invoke(proj, *first));
return {std::move(first), std::move(f)};
}
template<ranges::input_range R, class Proj = std::identity,
std::indirectly_unary_invocable
<std::projected<ranges::iterator_t<R>, Proj>> Fun>
constexpr ranges::for_each_result<ranges::borrowed_iterator_t<R>, Fun>
operator()(R&& r, Fun f, Proj proj = {}) const
{
return (*this)(ranges::begin(r), ranges::end(r), std::move(f), std::ref(proj));
}
template<ranges::forward_range R, class Proj = std::identity,
std::indirectly_unary_invocable
<std::projected<ranges::iterator_t<R>, Proj>> Fun>
constexpr ranges::for_each_result<ranges::borrowed_iterator_t<R>, Fun>
operator()(R&& r, Fun f, Proj proj = {}) const
{
return (*this)(ranges::begin(r),
ranges::next(ranges::begin(r), ranges::end(r)),
std::move(f), std::ref(proj));
}
};
inline constexpr for_each_fn for_each;
|
例
次の例では、ラムダ式を使用してベクタのすべての要素をインクリメントし、次にオーバーロードされた operator() を呼び出し可能オブジェクトで使用してそれらの合計を計算します。なお、合計を計算するには、専用のアルゴリズム std::accumulate を使用することをお勧めします。
このコードを実行する
#include <algorithm>
#include <cassert>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
struct Sum
{
void operator()(int n) { sum += n; }
int sum {0};
};
int main()
{
namespace ranges = std::ranges;
std::vector<int> nums {3, 4, 2, 8, 15, 267};
auto print = [](const auto& n) { std::cout << ' ' << n; };
std::cout << "before:";
ranges::for_each(std::as_const(nums), print);
print('\n');
ranges::for_each(nums, [](int& n) { ++n; });
// calls Sum::operator() for each number
auto [i, s] = ranges::for_each(nums.begin(), nums.end(), Sum());
assert(i == nums.end());
std::cout << "after: ";
ranges::for_each(nums.cbegin(), nums.cend(), print);
std::cout << "\n" "sum: " << s.sum << '\n';
using pair = std::pair<int, std::string>;
std::vector<pair> pairs {{1,"one"}, {2,"two"}, {3,"tree"}};
std::cout << "project the pair::first: ";
ranges::for_each(pairs, print, [](const pair& p) { return p.first; });
std::cout << "\n" "project the pair::second:";
ranges::for_each(pairs, print, &pair::second);
print('\n');
}
出力:
before: 3 4 2 8 15 267
after: 4 5 3 9 16 268
sum: 305
project the pair::first: 1 2 3
project the pair::second: one two tree
関連項目
| 適用する単項関数オブジェクトを要素に範囲から (関数テンプレート) | |
(C++20) |
関数オブジェクトをシーケンスの最初のN要素に適用する (アルゴリズム関数オブジェクト) |
(C++20) |
関数を範囲内の要素に適用する (アルゴリズム関数オブジェクト) |
範囲ベースのfor ループ(C++11)
|
範囲に対してループを実行する |