名稱空間
變體
操作

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

來自 cppreference.com
< cpp‎ | 演算法‎ | 範圍
 
C++
 
演算法庫
有約束演算法與針對範圍的演算法 (C++20)
有約束的演算法，例如 ranges::copy、 ranges::sort 等……
執行策略 (C++17)
排序及相關操作
劃分操作
排序操作
二分搜尋操作
（於已劃分範圍上）
集合操作（於已排序範圍上）
歸併操作（於已排序範圍上）
堆操作
最小/最大值操作
(C++11)
(C++17)
字典序比較操作
(C++20)
排列操作
C 庫
數值操作
未初始化記憶體上的操作
 
受約束演算法
此選單中的所有名稱均屬於名稱空間 std::ranges
非修改序列操作
修改序列操作
劃分操作
排序操作
二分查詢操作（在已排序的範圍內）
       
       
    
集合操作（於已排序範圍上）
堆操作
最小/最大值操作
       
       
排列操作
摺疊操作
數值操作
(C++23)            
對未初始化儲存的操作
返回型別
 
定義於標頭檔案 <algorithm>
呼叫簽名 (Call signature)
(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 >
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 = {} );
 (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> >
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 = {} );
 (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 >
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 = {} );
 (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 {};

[編輯] 注意

特性測試宏 值 標準 特性
__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)

[編輯] 參閱

(C++20)(C++20)
 用另一個值替換所有滿足特定條件的值
(演算法函式物件)[編輯]
 複製一個範圍，同時用另一個值替換滿足特定條件的元素
(函式模板) [編輯]
取自 "https://cppreference.tw/mwiki/index.php?title=cpp/algorithm/ranges/replace_copy&oldid=180566"