std::ranges::replace_copy, std::ranges::replace_copy_if, std::ranges::replace_copy_result, std::ranges::replace_copy_if_result - cppreference.com (original) (raw)

Copies the elements from the source range [first, last) to the destination range beginning at result, replacing all elements satisfying specific criteria with new_value. The behavior is undefined if the source and destination ranges overlap.

1. Replaces all elements that are equal to old_value, using std::invoke(proj, *(first + (i - result))) == old_value to compare.

2. Replaces all elements for which the predicate pred evaluates to true, where the evaluating expression is std::invoke(pred, std::invoke(proj, *(first + (i - result)))).

2,4) Same as (1,3), but uses r as the source range, as if using ranges::begin(r) as first, and ranges::end(r) as last.

The function-like entities described on this page are algorithm function objects (informally known as niebloids), that is:

• Explicit template argument lists cannot be specified when calling any of them.
• None of them are visible to argument-dependent lookup.
• When any of them are found by normal unqualified lookup as the name to the left of the function-call operator, argument-dependent lookup is inhibited.

Contents

• 1 Parameters
• 2 Return value
• 3 Complexity
• 4 Possible implementation
• 5 Notes
• 6 Example
• 7 See also

[edit] Parameters

[edit] Return value

{last, result + N}, where

[edit] Complexity

Exactly N applications of the corresponding predicate comp and any projection proj.

[edit] Possible implementation

[edit] Notes

[edit] Example

#include #include #include #include #include   void println(const auto rem, const auto& v) { for (std::cout << rem << ": "; const auto& e : v) std::cout << e << ' '; std::cout << '\n'; }   int main() {
std::vector o;   std::array p{1, 6, 1, 6, 1, 6}; o.resize(p.size()); println("p", p); std::ranges::replace_copy(p, o.begin(), 6, 9); println("o", o);   std::array q{1, 2, 3, 6, 7, 8, 4, 5}; o.resize(q.size()); println("q", q); std::ranges::replace_copy_if(q, o.begin(), [](int x) { return 5 < x; }, 5); println("o", o);   std::vector<std::complex> r{{1, 3}, {2, 2}, {4, 8}}; std::vector<std::complex> s(r.size()); println("r", r); #ifdef __cpp_lib_algorithm_default_value_type std::ranges::replace_copy(r, s.begin(), {1, 3}, // T1 gets deduced {2.2, 4.8}); // T2 gets deduced #else std::ranges::replace_copy(r, s.begin(), std::complex{1, 3}, std::complex{2.2, 4.8}); #endif println("s", s);   std::vector<std::complex> b{{1, 3}, {2, 2}, {4, 8}}, d(b.size()); println("b", b); #ifdef __cpp_lib_algorithm_default_value_type std::ranges::replace_copy_if(b, d.begin(), z){ return std::abs(z) < 5; }, {4, 2}); // Possible, since the T is deduced. #else std::ranges::replace_copy_if(b, d.begin(), z){ return std::abs(z) < 5; }, std::complex{4, 2}); #endif println("d", d); }

Output:

p: 1 6 1 6 1 6 o: 1 9 1 9 1 9 q: 1 2 3 6 7 8 4 5 o: 1 2 3 5 5 5 4 5 r: (1,3) (2,2) (4,8) s: (2.2,4.8) (2,2) (4,8) b: (1,3) (2,2) (4,8) d: (4,2) (4,2) (4,8)

[edit] See also