std::ranges::replace_copy,std::ranges::replace_copy_if,std::ranges::replace_copy_result,(3)

NAME
std::ranges::replace_copy,std::ranges::replace_copy_if,std::ranges::replace_copy_result, - std::ranges::replace_copy,std::ranges::replace_copy_if,std::ranges::replace_copy_result,

Synopsis
Defined in header <algorithm> Call signature template< std::input_iterator I, std::sentinel_for<I> S, class T1, class T2,
          std::output_iterator<const T2&> O, class Proj = std::identity > requires std::indirectly_copyable<I, O> && (since
         std::indirect_binary_predicate C++20)
             <ranges::equal_to, std::projected<I, (until Proj>, const T1*> C++26) constexpr replace_copy_result<I, O>
    replace_copy( I first, S last, O result, const T1& old_value,
                  const T2& new_value, Proj proj = {} ); template< std::input_iterator I, std::sentinel_for<I> S,
          class O, class Proj = std::identity,
          class T1 = std::projected_value_t<I, Proj>,
          class T2 = std::iter_value_t<O> > requires std::indirectly_copyable<I, O> &&
         std::indirect_binary_predicate (since
             <ranges::equal_to, std::projected<I, C++26) Proj>, const T1*> &&
         std::output_iterator<O, const T2&> constexpr replace_copy_result<I, O>
    replace_copy( I first, S last, O result, const T1& old_value,
                  const T2& new_value, Proj proj = {} ); template< ranges::input_range R, class T1, class T2,
          std::output_iterator<const T2&> O, class Proj = std::identity > requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
         std::indirect_binary_predicate (since
             <ranges::equal_to, C++20)
              std::projected<ranges::iterator_t<R>, (until Proj>, const T1*> C++26) constexpr replace_copy_result<ranges::borrowed_iterator_t<R>, O>
    replace_copy( R&& r, O result, const T1& old_value,
                  const T2& new_value, Proj proj = {} ); template< ranges::input_range R,
          class O, class Proj = std::identity,
          class T1 = std::projected_value_t<ranges::iterator_t<R>, Proj>,
          class T2 = std::iter_value_t<O> > requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
         std::indirect_binary_predicate
             <ranges::equal_to, (since
              std::projected<ranges::iterator_t<R>, C++26) Proj>, const T1*> &&
         std::output_iterator<O, const T2&> constexpr replace_copy_result<ranges::borrowed_iterator_t<R>, O>
    replace_copy( R&& r, O result, const T1& old_value,
                  const T2& new_value, Proj proj = {} ); template< std::input_iterator I, std::sentinel_for<I> (1) S,
          class T, std::output_iterator<const T&> O,
          class Proj = std::identity,
                        (since std::indirect_unary_predicate<std::projected<I, Proj>> C++20) Pred > (until requires std::indirectly_copyable<I, O> C++26) constexpr replace_copy_if_result<I, O>
    replace_copy_if( I first, S last, O result, Pred pred,
                     const T& new_value, Proj proj = {} ); template< std::input_iterator I, std::sentinel_for<I> S, (2)
          class O, class T = std::iter_value_t<O>
          class Proj = std::identity, std::indirect_unary_predicate<std::projected<I, Proj>> Pred > (since requires std::indirectly_copyable<I, O> && C++26) std::output_iterator<O, const T&> constexpr replace_copy_if_result<I, O>
    replace_copy_if( I first, S last, O result, Pred pred,
                     const T& new_value, Proj proj = {} ); template< ranges::input_range R,
          class T, std::output_iterator<const T&> O,
          class Proj = std::identity,
          std::indirect_unary_predicate (3)
              <std::projected<ranges::iterator_t<R>, Proj>> Pred > (since requires C++20) std::indirectly_copyable<ranges::iterator_t<R>, O> (until constexpr C++26) replace_copy_if_result<ranges::borrowed_iterator_t<R>, O>
    replace_copy_if( R&& r, O result, Pred pred,
                     const T& new_value, Proj proj = {} ); template< ranges::input_range R,
          class O, class T = std::iter_value_t<O>
          class Proj = std::identity, (4)
          std::indirect_unary_predicate
              <std::projected<ranges::iterator_t<R>, Proj>> Pred > requires (since std::indirectly_copyable<ranges::iterator_t<R>, O> && C++26)
         std::output_iterator<O, const T&> constexpr replace_copy_if_result<ranges::borrowed_iterator_t<R>, O>
    replace_copy_if( R&& r, O result, Pred pred,
                     const T& new_value, Proj proj = {} );

Helper types
template< class I, class O > (since using replace_copy_result = ranges::in_out_result<I, (5) C++20) O>; template< class I, class O > (since using replace_copy_if_result = (6) C++20) ranges::in_out_result<I, O>;
   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.
   3) 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 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.
   In practice, they may be implemented as function objects, or with special compiler
   extensions.

Parameters
   first, last - the range of elements to copy
   r - the range of elements to copy
   result - the beginning of the destination range
   old_value - the value of elements to replace
   new_value - the value to use as a replacement
   pred - predicate to apply to the projected elements
   proj - projection to apply to the elements.

Return value
   {last, result + N}, where
   1,3) N = ranges::distance(first, last);
   2,4) N = ranges::distance(r).

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

Possible implementation
                        replace_copy (1,2)
 struct replace_copy_fn
 {
     template<std::input_iterator I, std::sentinel_for<I> S,
              class O, class Proj = std::identity,
              class T1 = std::projected_value_t<I, Proj>,
              class T2 = std::iter_value_t<O>>
     requires std::indirectly_copyable<I, O> &&
              std::indirect_binary_predicate
                  <ranges::equal_to, std::projected<I, Proj>, const T1*> &&
              std::output_iterator<O, const T2&>
     constexpr ranges::replace_copy_result<I, O>
         operator()(I first, S last, O result, const T1& old_value,
                    const T2& new_value, Proj proj = {}) const
     {
         for (; first != last; ++first, ++result)
             *result = (std::invoke(proj, *first) == old_value) ? new_value : *first;
         return {std::move(first), std::move(result)};
     }
     template<ranges::input_range R, class O, class Proj = std::identity,
              class T1 = std::projected_value_t<ranges::iterator_t<R>, Proj>,
              class T2 = std::iter_value_t<O>>
     requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
              std::indirect_binary_predicate
                  <ranges::equal_to,
                   std::projected<ranges::iterator_t<R>, Proj>, const T1*>
     constexpr ranges::replace_copy_result<ranges::borrowed_iterator_t<R>, O>
         operator()(R&& r, O result, const T1& old_value,
                    const T2& new_value, Proj proj = {}) const
     {
         return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                        old_value, new_value, std::move(proj));
     }
 };
 inline constexpr replace_copy_fn replace_copy {};
                        replace_copy_if (3,4)
 struct replace_copy_if_fn
 {
     template<std::input_iterator I, std::sentinel_for<I> S,
              class O, class T = std::iter_value_t<O>
              class Proj = std::identity,
              std::indirect_unary_predicate<std::projected<I, Proj>> Pred>
     requires std::indirectly_copyable<I, O> && std::output_iterator<O, const T&>
     constexpr ranges::replace_copy_if_result<I, O>
         operator()(I first, S last, O result, Pred pred,
                    const T& new_value, Proj proj = {}) const
     {
         for (; first != last; ++first, ++result)
              *result = std::invoke(pred, std::invoke(proj, *first)) ? new_value : *first;
         return {std::move(first), std::move(result)};
     }
     template<ranges::input_range R, class O, class T = std::iter_value_t<O>
              class Proj = std::identity,
              std::indirect_unary_predicate
                  <std::projected<ranges::iterator_t<R>, Proj>> Pred>
     requires std::indirectly_copyable<ranges::iterator_t<R>, O> &&
              std::output_iterator<O, const T&>
     constexpr ranges::replace_copy_if_result<ranges::borrowed_iterator_t<R>, O>
         operator()(R&& r, O result, Pred pred,
                    const T& new_value, Proj proj = {}) const
     {
         return (*this)(ranges::begin(r), ranges::end(r), std::move(result),
                        std::move(pred), new_value, std::move(proj));
     }
 };
 inline constexpr replace_copy_if_fn replace_copy_if {};

Notes
             Feature-test macro Value Std Feature
   __cpp_lib_algorithm_default_value_type 202403 (C++26) list-initialization for
                        algorithms (1-4)

Example
// Run this code
 #include <algorithm>
 #include <array>
 #include <complex>
 #include <iostream>
 #include <vector>
 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<int> 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<short>> r{{1, 3}, {2, 2}, {4, 8}};
     std::vector<std::complex<float>> 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<short>{1, 3},
                        std::complex<float>{2.2, 4.8});
     #endif
     println("s", s);
     std::vector<std::complex<double>> 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(),
             [](std::complex<double> z){ return std::abs(z) < 5; },
             {4, 2}); // Possible, since the T is deduced.
     #else
         std::ranges::replace_copy_if(b, d.begin(),
             [](std::complex<double> z){ return std::abs(z) < 5; },
             std::complex<double>{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)

See also
   ranges::replace replaces all values satisfying specific criteria with another
   ranges::replace_if value
   (C++20) (niebloid)
   (C++20)
   replace_copy copies a range, replacing elements satisfying specific criteria
   replace_copy_if with another value
                      (function template)