std::ranges::replace_copy, std::ranges::replace_copy_if, std::ranges::replace_copy_result, std::ranges::replace_copy_if_result

定义在头文件 `<algorithm>` 中
调用签名
	(1)
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 = {} );			(自 C++20 起) (直到 C++26)
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 = {} );			(自 C++26 起)
		(2)
template< ranges::input_range R, class T1, class T2, std::output_iterator<const T2&> O, class Proj = std::identity > 需要 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 = {} );				(自 C++20 起) (直到 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> > 需要 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 = {} );				(自 C++26 起)
			(3)
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 = {} );					(自 C++20 起) (直到 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 = {} );					(自 C++26 起)
				(4)
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 = {} );						(自 C++20 起) (直到 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 > 需要 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 = {} );						(自 C++26 起)
辅助类型
template< class I, class O > using replace_copy_result = ranges::in_out_result<I, O>;					(5)	(自 C++20 起)
template< class I, class O > using replace_copy_if_result = ranges::in_out_result<I, O>;					(6)	(自 C++20 起)

将源范围 [first, last) 中的元素复制到以 result 开始的目标范围，并将满足特定条件的所有元素替换为 new_value。如果源范围和目标范围重叠，则行为未定义。

1) 替换所有等于 old_value 的元素，使用 std::invoke(proj, *(first + (i - result))) == old_value 进行比较。

3) 替换所有使谓词 pred 评估为 true 的元素，其中评估表达式为 std::invoke(pred, std::invoke(proj, *(first + (i - result)))).

2,4) 与 (1,3) 相同，但使用 r 作为源范围，就像使用 ranges::begin(r) 作为 first，以及 ranges::end(r) 作为 last。

本页上描述的功能式实体是 niebloids，也就是说

调用任何这些实体时，不能指定显式模板参数列表。
它们都不对依赖于参数的查找可见。
当通过普通无限定查找找到它们作为函数调用运算符左侧的名称时，依赖于参数的查找会被禁止。

在实践中，它们可以用函数对象或特殊的编译器扩展来实现。

[编辑] 参数

first, last	-	要复制的元素范围
r	-	要复制的元素范围
result	-	目标范围的开始
old_value	-	要替换的元素的值
new_value	-	用作替换的值
pred	-	要应用于投影元素的谓词
proj	-	要应用于元素的投影。

[编辑] 返回值

{last, result + N}，其中

1,3) N = ranges::distance(first, last);

2,4) N = ranges::distance(r).

[编辑] 复杂度

正好 N 次对应的谓词 comp 和任何投影 proj 的应用。

[编辑] 可能的实现

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 {};

[编辑] 备注

功能测试宏	值	Std	功能
`__cpp_lib_algorithm_default_value_type`	202403	(C++26)	列表初始化用于算法 (1-4)

[编辑] 示例

运行此代码

#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);
}

输出

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)

[编辑] 参见

ranges::replaceranges::replace_if (C++20)(C++20)	用另一个值替换满足特定条件的所有值 (niebloid)[编辑]
replace_copyreplace_copy_if	复制一个范围，用另一个值替换满足特定条件的元素 (函数模板) [编辑]

编译器支持
独立和托管
语言
标准库
标准库头文件
命名要求
功能测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用实用程序库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
执行支持库 (C++26)
技术规范
符号索引
外部库

cppreference.com

命名空间

变体

视图

操作