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)