std::ranges...opy_result,(3)

📦 version 2024.07.05, in nixpkgs unstable, opensuse-leap 16.0

✨ NAME ✨

std::ranges::replace_copy, std::ranges::replace_copy_if, std::ranges::replace_copy_result — bestie, you've landed on the <algorithm> girlies, straight out of the C++ Standard Library (that's the manual name, mwah 💖). This trio is literally the "copy it but swap the matching bits" squad and they're about to eat. 🎀

🌸 Synopsis 🌸

Defined in header <algorithm> — say it with me, <algorithm> ✨

Call signature

okay so there's a lot of overloads here, but don't panic, they're all the same vibe in different flavours. 🧚

Overload (1) — iterator/sentinel one, (since C++20) (until C++26):

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> &&
           std::indirect_binary_predicate
               <ranges::equal_to, std::projected<I, Proj>, const T1*>
constexpr replace_copy_result<I, O>
    replace_copy( I first, S last, O result, const T1& old_value,
                  const T2& new_value, Proj proj = {} );

Overload (2) — the shiny new (since C++26) version of the same thing:

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 replace_copy_result<I, O>
    replace_copy( I first, S last, O result, const T1& old_value,
                  const T2& new_value, Proj proj = {} );

Overload (3) — range version, (since C++20) (until C++26):

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
               <ranges::equal_to,
                std::projected<ranges::iterator_t<R>, Proj>, const T1*>
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 = {} );

Overload (4) — range version, (since C++26):

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*> &&
           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 = {} );

Then the _if girlies 💅 — overload (1), (since C++20) (until C++26):

template<
    std::input_iterator I, std::sentinel_for<I> S,
    class T, std::output_iterator<const T&> O,
    class Proj = std::identity,
    std::indirect_unary_predicate<std::projected<I, Proj>> Pred
> requires std::indirectly_copyable<I, O>
constexpr replace_copy_if_result<I, O>
    replace_copy_if( I first, S last, O result, Pred pred,
                     const T& new_value, Proj proj = {} );

Overload (2), (since C++26):

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 replace_copy_if_result<I, O>
    replace_copy_if( I first, S last, O result, Pred pred,
                     const T& new_value, Proj proj = {} );

Overload (3), (since C++20) (until C++26):

template<
    ranges::input_range R,
    class T, std::output_iterator<const 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>
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 = {} );

Overload (4), (since C++26):

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 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 🦋

These are just little aliases, so lowkey the easiest part of the whole page, no cap:

template< class I, class O >          // (5)  (since C++20)
using replace_copy_result = ranges::in_out_result<I, O>;

template< class I, class O >          // (6)  (since C++20)
using replace_copy_if_result = ranges::in_out_result<I, O>;

💖 Description 💖

Okay so here's the whole vibe: these functions copy the elements from the source range [first, last) into the destination range beginning at result, and along the way they replace every element that satisfies your specific criteria with new_value. Simple as that, iconic behaviour. ✨

⚠️ The behavior is undefined if the source and destination ranges overlap. Not "undefined-ish", not "we'll figure it out" — undefined, bestie. Don't do it. 😭

(1) Replaces all elements that are equal to old_value, using std::invoke(proj, *(first + (i - result))) == old_value to compare. Like, that's literally the comparison expression, I'm not making it up. 🫶
(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. iykyk 💅

🎀 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 ⭐

It gives you back {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. Not N+1, not "a few", exactly N. She's precise like that. 👑

🌈 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 girlie check 🧚:

__cpp_lib_algorithm_default_value_type — value 202403 — Std C++26 — feature: list-initialization for algorithms (1-4)

✨ EXAMPLE ✨

okay bestie, this demo is literally showing off std::ranges::replace_copy and std::ranges::replace_copy_if in the wild 💅 it prints containers before and after, does a little complex-number glow-up, and even has the #ifdef __cpp_lib_algorithm_default_value_type branch situation so you can see the deduced-type version and the fallback version. slay.

// 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 👀

these are the related besties, and yes, every single one is getting its moment:

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

💖 source: <code>http://cppreference.com</code> · version/date: <code>2024.06.10</code> · page: <code>std::ranges...opy_result,(3)</code> 💖

📦 where this page comes from

nixpkgs unstable: stdman 2024.07.05
opensuse-leap 16.0: stdman 2024.07.05-bp160.1.9 · MIT
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms