std::ranges::transform、std::ranges::unary_transform_result、std::ranges::binary_transform_result
| ヘッダー <algorithm> で定義 |
||
| 呼び出しシグネチャ |
||
| template< std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity > |
(1) | (C++20以降) |
| template< ranges::input_range R, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity > |
(2) | (C++20以降) |
| template< std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, |
(3) | (C++20以降) |
| template< ranges::input_range R1, ranges::input_range R2, |
(4) | (C++20以降) |
| ヘルパー型 |
||
| template< class I, class O > using unary_transform_result = ranges::in_out_result<I, O>; |
(5) | (C++20以降) |
| template< class I1, class I2, class O > using binary_transform_result = ranges::in_in_out_result<I1, I2, O>; |
(6) | (C++20以降) |
指定された関数を範囲に適用し、結果を別の範囲の result から始まる位置に格納します。
[first1, last1) (射影 proj による射影後) で定義された範囲に適用されます。[first1, last1) で定義され、もう1つは [first2, last2) で定義されます (それぞれ射影 proj1 と proj2 による射影後)。このページで説明されている関数のようなエンティティは、アルゴリズム関数オブジェクト（非公式にはニーブロイドとして知られている）です。つまり、
- これらのいずれかを呼び出す際に、明示的なテンプレート引数リストを指定することはできません。
- これらのいずれも実引数依存の名前探索には見えません。
- これらのいずれかが関数呼び出し演算子の左側の名前として通常の非修飾名探索によって見つかった場合、実引数依存の名前探索は抑制されます。
目次 |
[edit] パラメータ
| first1, last1 | - | 変換する最初の要素の範囲を定義するイテレータ-センチネルペア |
| r, r1 | - | 変換する最初の要素の範囲 |
| first2, last2 | - | 変換する2番目の要素の範囲を定義するイテレータ-センチネルペア |
| r2 | - | 変換する2番目の範囲 |
| 結果 | - | first1 または first2 と等しくなる可能性のある、宛先範囲の開始位置 |
| op, binary_op | - | 射影された要素に適用する操作 |
| proj1 | - | 最初の範囲の要素に適用する射影 |
| proj2 | - | 2番目の範囲の要素に適用する射影 |
[edit] 戻り値
unary_transform_result は、last と等しい入力イテレータと、変換された最後の要素の次の要素を指す出力イテレータを含みます。binary_transform_result は、範囲 [first1, last1) および [first2, last2) からの最後の変換要素をそれぞれ in1 および in2 として指す入力イテレータ、および変換された最後の要素の次の要素を指す出力イテレータを out として含みます。[edit] 複雑性
[edit] 実装例
struct transform_fn { // First version template<std::input_iterator I, std::sentinel_for<I> S, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity> requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<I, Proj>>> constexpr ranges::unary_transform_result<I, O> operator()(I first1, S last1, O result, F op, Proj proj = {}) const { for (; first1 != last1; ++first1, (void)++result) *result = std::invoke(op, std::invoke(proj, *first1)); return {std::move(first1), std::move(result)}; } // Second version template<ranges::input_range R, std::weakly_incrementable O, std::copy_constructible F, class Proj = std::identity> requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<ranges::iterator_t<R>, Proj>>> constexpr ranges::unary_transform_result<ranges::borrowed_iterator_t<R>, O> operator()(R&& r, O result, F op, Proj proj = {}) const { return (*this)(ranges::begin(r), ranges::end(r), std::move(result), std::move(op), std::move(proj)); } // Third version template<std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2, std::weakly_incrementable O, std::copy_constructible F, class Proj1 = std::identity, class Proj2 = std::identity> requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<I1, Proj1>, std::projected<I2, Proj2>>> constexpr ranges::binary_transform_result<I1, I2, O> operator()(I1 first1, S1 last1, I2 first2, S2 last2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}) const { for (; first1 != last1 && first2 != last2; ++first1, (void)++first2, (void)++result) *result = std::invoke(binary_op, std::invoke(proj1, *first1), std::invoke(proj2, *first2)); return {std::move(first1), std::move(first2), std::move(result)}; } // Fourth version template<ranges::input_range R1, ranges::input_range R2, std::weakly_incrementable O, std::copy_constructible F, class Proj1 = std::identity, class Proj2 = std::identity> requires std::indirectly_writable<O, std::indirect_result_t<F&, std::projected<ranges::iterator_t<R1>, Proj1>, std::projected<ranges::iterator_t<R2>, Proj2>>> constexpr ranges::binary_transform_result<ranges::borrowed_iterator_t<R1>, ranges::borrowed_iterator_t<R2>, O> operator()(R1&& r1, R2&& r2, O result, F binary_op, Proj1 proj1 = {}, Proj2 proj2 = {}) const { return (*this)(ranges::begin(r1), ranges::end(r1), ranges::begin(r2), ranges::end(r2), std::move(result), std::move(binary_op), std::move(proj1), std::move(proj2)); } }; inline constexpr transform_fn transform; |
[edit] 注意
ranges::transform は、op または binary_op の順序付けられた適用を保証しません。シーケンスに順番に適用する関数、またはシーケンスの要素を変更する関数を適用するには、ranges::for_each を使用してください。
[edit] 例
次のコードは、std::toupper 関数を使用して文字列をインプレースで大文字に変換し、次に各 char をその序数値に変換するために ranges::transform を使用します。次に、射影を使用した ranges::transform が、std::vector<Foo> の要素を char に変換して std::string を埋めるために使用されます。
#include <algorithm> #include <cctype> #include <functional> #include <iostream> #include <string> #include <vector> int main() { std::string s{"hello"}; auto op = [](unsigned char c) -> unsigned char { return std::toupper(c); }; namespace ranges = std::ranges; // uppercase the string in-place ranges::transform(s.begin(), s.end(), s.begin(), op ); std::vector<std::size_t> ordinals; // convert each char to size_t ranges::transform(s, std::back_inserter(ordinals), [](unsigned char c) -> std::size_t { return c; }); std::cout << s << ':'; for (auto ord : ordinals) std::cout << ' ' << ord; // double each ordinal ranges::transform(ordinals, ordinals, ordinals.begin(), std::plus{}); std::cout << '\n'; for (auto ord : ordinals) std::cout << ord << ' '; std::cout << '\n'; struct Foo { char bar; }; const std::vector<Foo> f = {{'h'},{'e'},{'l'},{'l'},{'o'}}; std::string result; // project, then uppercase ranges::transform(f, std::back_inserter(result), op, &Foo::bar); std::cout << result << '\n'; }
出力
HELLO: 72 69 76 76 79 144 138 152 152 158 HELLO
[edit] 参照
| (C++20) |
範囲内の要素に単項関数オブジェクトを適用する (アルゴリズム関数オブジェクト) |
各要素に変換関数を適用するシーケンスの view(クラステンプレート) (rangeアダプタオブジェクト) | |
| 範囲内の要素に関数を適用し、結果を結果範囲に格納する (関数テンプレート) |
