Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

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

      From cppreference.com
      <cpp‎ |algorithm‎ |ranges
       
       
      Algorithm library
      Constrained algorithms and algorithms on ranges(C++20)
      Constrained algorithms, e.g.ranges::copy,ranges::sort, ...
      Execution policies(C++17)
      Sorting and related operations
      Partitioning operations
      Sorting operations
      Binary search operations
      (on partitioned ranges)
      Set operations (on sorted ranges)
      Merge operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      (C++11)
      (C++17)
      Lexicographical comparison operations
      Permutation operations
      C library
      Numeric operations
      Operations on uninitialized memory
       
      Constrained algorithms
      All names in this menu belong to namespacestd::ranges
      Non-modifying sequence operations
      Modifying sequence operations
      Partitioning operations
      Sorting operations
      Binary search operations (on sorted ranges)
             
             
      Set operations (on sorted ranges)
      Heap operations
      Minimum/maximum operations
      Permutation operations
      Fold operations
      Operations on uninitialized storage
      Return types
       
      Defined in header<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>
      requiresstd::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={});
      		(since C++20)
      (until 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>>
      requiresstd::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={});
      		(since C++26)
      (2)
      template<ranges::input_range R,class T1,class T2,

               std::output_iterator<const T2&> O,class Proj=std::identity>
      requiresstd::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={});
      		(since C++20)
      (until 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>>
      requiresstd::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={});
      		(since 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>
      requiresstd::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={});
      		(since C++20)
      (until 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>
      requiresstd::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={});
      		(since 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>
      requiresstd::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={});
      		(since C++20)
      (until 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>
      requiresstd::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={});
      		(since C++26)
      Helper types
      template<class I,class O>
      using replace_copy_result=ranges::in_out_result<I, O>;
      		 (5)(since C++20)
      template<class I,class O>
      using replace_copy_if_result=ranges::in_out_result<I, O>;
      		 (6)(since C++20)

      Copies the elements from the source range[first, last) to the destination range beginning atresult, replacing all elements satisfying specific criteria withnew_value. The behavior is undefined if the source and destination ranges overlap.

      1) Replaces all elements that are equal toold_value, usingstd::invoke(proj,*(first+(i- result)))== old_value to compare.
      3) Replaces all elements for which the predicatepred evaluates totrue, where the evaluating expression isstd::invoke(pred,std::invoke(proj,*(first+(i- result)))).
      2,4) Same as(1,3), but usesr as the source range, as if usingranges::begin(r) asfirst, andranges::end(r) aslast.

      The function-like entities described on this page arealgorithm function objects (informally known asniebloids), that is:

      Contents

      [edit]Parameters

      first, last - the iterator-sentinel pair defining therange 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.

      [edit]Return value

      {last, result+ N}, where

      1,3)N=ranges::distance(first, last);
      2,4)N=ranges::distance(r).

      [edit]Complexity

      ExactlyN applications of the corresponding predicatecomp and any projectionproj.

      [edit]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>>    requiresstd::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>>    requiresstd::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));}}; inlineconstexpr 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>    requiresstd::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>    requiresstd::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));}}; inlineconstexpr replace_copy_if_fn replace_copy_if{};

      [edit]Notes

      Feature-test macroValueStdFeature
      __cpp_lib_algorithm_default_value_type202403(C++26)list-initialization for algorithms(1-4)

      [edit]Example

      Run this code
      #include <algorithm>#include <array>#include <complex>#include <iostream>#include <vector> void println(constauto rem,constauto& v){for(std::cout<< rem<<": ";constauto& 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){return5< 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 6o: 1 9 1 9 1 9q: 1 2 3 6 7 8 4 5o: 1 2 3 5 5 5 4 5r: (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)

      [edit]See also

      replaces all values satisfying specific criteria with another value
      (algorithm function object)[edit]
      copies a range, replacing elements satisfying specific criteria with another value
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/algorithm/ranges/replace_copy&oldid=180566"
      [8]ページ先頭
      ©2009-2025 Movatter.jp