Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::replace,std::replace_if

      From cppreference.com
      <cpp‎ |algorithm
       
       
      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
       
      Defined in header<algorithm>
      (1)
      template<class ForwardIt,class T>

      void replace( ForwardIt first, ForwardIt last,

                   const T& old_value,const T& new_value);
      		(constexpr since C++20)
      (until C++26)
      template<class ForwardIt,class T=typenamestd::iterator_traits

                                               <ForwardIt>::value_type>
      constexprvoid replace( ForwardIt first, ForwardIt last,

                             const T& old_value,const T& new_value);
      		(since C++26)
      (2)
      template<class ExecutionPolicy,class ForwardIt,class T>

      void replace( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,

                   const T& old_value,const T& new_value);
      		(since C++17)
      (until C++26)
      template<class ExecutionPolicy,class ForwardIt,

               class T=typenamestd::iterator_traits
                             <ForwardIt>::value_type>
      void replace( ExecutionPolicy&& policy,
                    ForwardIt first, ForwardIt last,

                   const T& old_value,const T& new_value);
      		(since C++26)
      (3)
      template<class ForwardIt,class UnaryPred,class T>

      void replace_if( ForwardIt first, ForwardIt last,

                       UnaryPred p,const T& new_value);
      		(constexpr since C++20)
      (until C++26)
      template<class ForwardIt,class UnaryPred,

               class T=typenamestd::iterator_traits
                             <ForwardIt>::value_type>>
      constexprvoid replace_if( ForwardIt first, ForwardIt last,

                                 UnaryPred p,const T& new_value);
      		(since C++26)
      (4)
      template<class ExecutionPolicy,

               class ForwardIt,class UnaryPred,class T>
      void replace_if( ExecutionPolicy&& policy,
                       ForwardIt first, ForwardIt last,

                       UnaryPred p,const T& new_value);
      		(since C++17)
      (until C++26)
      template<class ExecutionPolicy,

               class ForwardIt,class UnaryPred,
               class T=typenamestd::iterator_traits
                             <ForwardIt>::value_type>>
      void replace_if( ExecutionPolicy&& policy,
                       ForwardIt first, ForwardIt last,

                       UnaryPred p,const T& new_value);
      		(since C++26)

      Replaces all elements in the range[first, last) withnew_value if they satisfy specific criteria.

      1) Replaces all elements that are equal toold_value (usingoperator==).
      3) Replaces all elements for which predicatep returnstrue.
      2,4) Same as(1,3), but executed according topolicy.
      These overloads participate in overload resolution only if all following conditions are satisfied:

      std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> istrue.

      		(until C++20)

      std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>> istrue.

      		(since C++20)

      If*first= new_value is invalid(until C++20)new_value is notwritable tofirst(since C++20), the program is ill-formed.

      Contents

      [edit]Parameters

      first, last - the pair of iterators defining therange of elements to process
      old_value - the value of elements to replace
      policy - theexecution policy to use
      p - unary predicate which returns ​true if the element value should be replaced.

      The expressionp(v) must be convertible tobool for every argumentv of type (possibly const)VT, whereVT is the value type ofForwardIt, regardless ofvalue category, and must not modifyv. Thus, a parameter type ofVT&is not allowed, nor isVT unless forVT a move is equivalent to a copy(since C++11).​

      new_value - the value to use as replacement
      Type requirements
      -
      ForwardIt must meet the requirements ofLegacyForwardIterator.
      -
      UnaryPred must meet the requirements ofPredicate.

      [edit]Complexity

      Given\(\scriptsize N\)N asstd::distance(first, last):

      1,2) Exactly\(\scriptsize N\)N comparisons usingoperator==.
      3,4) Exactly\(\scriptsize N\)N applications of the predicatep.

      [edit]Exceptions

      The overloads with a template parameter namedExecutionPolicy report errors as follows:

      • If execution of a function invoked as part of the algorithm throws an exception andExecutionPolicy is one of thestandard policies,std::terminate is called. For any otherExecutionPolicy, the behavior is implementation-defined.
      • If the algorithm fails to allocate memory,std::bad_alloc is thrown.

      [edit]Notes

      Because the algorithm takesold_value andnew_value by reference, it can have unexpected behavior if either is a reference to an element of the range[first, last).

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

      [edit]Possible implementation

      replace (1)
      template<class ForwardIt,class T=typenamestd::iterator_traits<ForwardIt>::value_type>void replace(ForwardIt first, ForwardIt last,const T& old_value,const T& new_value){for(; first!= last;++first)if(*first== old_value)*first= new_value;}
      replace_if (3)
      template<class ForwardIt,class UnaryPred,class T=typenamestd::iterator_traits<ForwardIt>::value_type>void replace_if(ForwardIt first, ForwardIt last,                UnaryPred p,const T& new_value){for(; first!= last;++first)if(p(*first))*first= new_value;}

      [edit]Example

      Run this code
      #include <algorithm>#include <array>#include <complex>#include <functional>#include <iostream> void println(constauto& seq){for(constauto& e: seq)std::cout<< e<<' ';std::cout<<'\n';} int main(){std::array<int,10> s{5,7,4,2,8,6,1,9,0,3}; // Replace all occurrences of 8 with 88.    std::replace(s.begin(), s.end(),8,88);    println(s); // Replace all values less than 5 with 55.    std::replace_if(s.begin(), s.end(),std::bind(std::less<int>(), std::placeholders::_1,5),55);    println(s); std::array<std::complex<double>,2> nums{{{1,3},{1,3}}};#ifdef __cpp_lib_algorithm_default_value_type        std::replace(nums.begin(), nums.end(),{1,3},{4,2});#else        std::replace(nums.begin(), nums.end(),std::complex<double>{1,3},std::complex<double>{4,2});#endif    println(nums);}

      Output:

      5 7 4 2 88 6 1 9 0 35 7 55 55 88 6 55 9 55 55(4,2), (4,2)

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      LWG 283C++98T was required to beCopyAssignable (andEqualityComparable
      forreplace), but the value type ofForwardIt is not
      alwaysT andT is not always writable toForwardIt      		required*first= new_value
      to be valid instead

      [edit]See also

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