std::replace, std::replace_if
Defined in header
<algorithm>
|
||
template< class ForwardIt, class T >
void replace( ForwardIt first, ForwardIt last, |
(1) | |
template< class ExecutionPolicy, class ForwardIt, class T >
void replace( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, |
(2) | (since C++17) |
template< class ForwardIt, class UnaryPredicate, class T >
void replace_if( ForwardIt first, ForwardIt last, |
(3) | |
template< class ExecutionPolicy, class ForwardIt, class UnaryPredicate, class T >
void replace_if( ExecutionPolicy&& policy, ForwardIt first, ForwardIt last, |
(4) | (since C++17) |
Replaces all elements satisfying specific criteria with new_value
in the range [first, last)
.
old_value
.p
returns true.policy
. These overloads do not participate in overload resolution unless std::is_execution_policy_v<std::decay_t<ExecutionPolicy>> is true
Contents |
[edit] Parameters
first, last | - | the range of elements to process |
old_value | - | the value of elements to replace |
policy | - | the execution policy to use. See execution policy for details. |
p | - | unary predicate which returns true if the element value should be replaced. The signature of the predicate function should be equivalent to the following: bool pred(const Type &a); The signature does not need to have const &, but the function must not modify the objects passed to it. |
new_value | - | the value to use as replacement |
Type requirements | ||
-
ForwardIt must meet the requirements of ForwardIterator .
|
||
-
UnaryPredicate must meet the requirements of Predicate .
|
[edit] Return value
(none)
[edit] Complexity
Exactly last - first
applications of the predicate.
[edit] Exceptions
The overloads with a template parameter named ExecutionPolicy
report errors as follows:
- If execution of a function invoked as part of the algorithm throws an exception,
-
- if
policy
is std::parallel_vector_execution_policy, std::terminate is called - if
policy
is std::sequential_execution_policy or std::parallel_execution_policy, the algorithm exits with an std::exception_list containing all uncaught exceptions. If there was only one uncaught exception, the algorithm may rethrow it without wrapping in std::exception_list. It is unspecified how much work the algorithm will perform before returning after the first exception was encountered. - if
policy
is some other type, the behavior is implementation-defined
- if
- If the algorithm fails to allocate memory (either for itself or to construct an std::exception_list when handling a user exception), std::bad_alloc is thrown.
[edit] Possible implementation
First version |
---|
template<class ForwardIt, class T> 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; } } } |
Second version |
template<class ForwardIt, class UnaryPredicate, class T> void replace_if(ForwardIt first, ForwardIt last, UnaryPredicate p, const T& new_value) { for (; first != last; ++first) { if(p(*first)) { *first = new_value; } } } |
[edit] Example
The following code at first replaces all occurrences of 8 with 88 in a vector of integers. Then it replaces all values less than 5 with 55.
#include <algorithm> #include <array> #include <iostream> #include <functional> int main() { std::array<int, 10> s{5, 7, 4, 2, 8, 6, 1, 9, 0, 3}; std::replace(s.begin(), s.end(), 8, 88); for (int a : s) { std::cout << a << " "; } std::cout << '\n'; std::replace_if(s.begin(), s.end(), std::bind(std::less<int>(), std::placeholders::_1, 5), 55); for (int a : s) { std::cout << a << " "; } std::cout << '\n'; }
Output:
5 7 4 2 88 6 1 9 0 3 5 7 55 55 88 6 55 9 55 55
[edit] See also
copies a range, replacing elements satisfying specific criteria with another value (function template) |
|
(parallelism TS)
|
parallelized version of std::replace (function template) |
(parallelism TS)
|
parallelized version of std::replace_if (function template) |