Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/algorithm/replace copy"

From cppreference.com
< cpp‎ | algorithm
m (Text replace - "ForwardIterator" to "ForwardIt")
(+type reqs)
Line 5: Line 5:
 
{{ddcl list item | num=1 |
 
{{ddcl list item | num=1 |
 
template< class InputIt, class OutputIt, class T >
 
template< class InputIt, class OutputIt, class T >
OutputIt replace_copy( InputIt first,
+
OutputIt replace_copy( InputIt first, InputIt last, OutputIt d_first,
                            InputIt last,
+
                      const T& old_value, const T& new_value );
                            OutputIt d_first,
+
                            const T& old_value,
+
                            const T& new_value );
+
 
}}
 
}}
 
{{ddcl list item | num=2 |
 
{{ddcl list item | num=2 |
 
template< class InputIt, class OutputIt, class UnaryPredicate, class T >
 
template< class InputIt, class OutputIt, class UnaryPredicate, class T >
OutputIt replace_copy_if( InputIt first,
+
OutputIt replace_copy_if( InputIt first, InputIt last, OutputIt d_first,
                                InputIt last,
+
                          UnaryPredicate p, const T& new_value );
                                OutputIt d_first,
+
                                UnaryPredicate p,
+
                                const T& new_value );
+
 
}}
 
}}
 
{{ddcl list end}}
 
{{ddcl list end}}
Line 28: Line 22:
 
{{param list item | d_first | the beginning of the destination range}}
 
{{param list item | d_first | the beginning of the destination range}}
 
{{param list item | old_value | the value of elements to replace}}
 
{{param list item | old_value | the value of elements to replace}}
{{param list pred1 | p | if the element value should be replaced | p1=ForwardIt}}
+
{{param list pred1 | p | if the element value should be replaced | p1=InputIt}}
 
{{param list item | new_value | the value to use as replacement}}
 
{{param list item | new_value | the value to use as replacement}}
 +
{{param list hreq}}
 +
{{param list req concept | InputIt | InputIterator}}
 +
{{param list req concept | OutputIt | OutputIterator}}
 
{{param list end}}
 
{{param list end}}
  
 
===Return value===
 
===Return value===
 
+
Iterator to the element past the last element copied.
iterator to the element past the last element copied.
+
  
 
===Complexity===
 
===Complexity===
 
 
Exactly {{tt|last - first}} applications of the predicate.
 
Exactly {{tt|last - first}} applications of the predicate.
  
Line 44: Line 39:
 
  | 1=
 
  | 1=
 
template<class InputIt, class OutputIt, class T>
 
template<class InputIt, class OutputIt, class T>
OutputIt replace_copy(InputIt first,
+
OutputIt replace_copy(InputIt first, InputIt last, OutputIt d_first,
                            InputIt last,
+
                      const T& old_value, const T& new_value)
                            OutputIt d_first,
+
                            const T& old_value,
+
                            const T& new_value)
+
 
{
 
{
 
     for (; first != last; ++first) {
 
     for (; first != last; ++first) {
Line 58: Line 50:
 
template<class InputIt, class OutputIt,  
 
template<class InputIt, class OutputIt,  
 
         class UnaryPredicate, class T>
 
         class UnaryPredicate, class T>
OutputIt replace_copy_if(InputIt first,
+
OutputIt replace_copy_if(InputIt first, InputIt last, OutputIt d_first,
                              InputIt last,
+
                        UnaryPredicate p, const T& new_value)
                              OutputIt d_first,
+
                              UnaryPredicate p,
+
                              const T& new_value)
+
 
{
 
{
 
     for (; first != last; ++first) {
 
     for (; first != last; ++first) {

Revision as of 04:56, 3 August 2012

 
 
Algorithm library
Constrained algorithms and algorithms on ranges (C++20)
Constrained algorithms, e.g. ranges::copy, ranges::sort, ...
Execution policies (C++17)
Non-modifying sequence operations
Batch operations
(C++17)
Search operations
(C++11)                (C++11)(C++11)

Modifying sequence operations
Copy operations
(C++11)
(C++11)
Swap operations
Transformation operations
replace_copyreplace_copy_if

Generation operations
Removing operations
Order-changing operations
(until C++17)(C++11)
(C++20)(C++20)
Sampling operations
(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
 

Template:ddcl list begin <tr class="t-dsc-header">

<td>
Defined in header <algorithm>
</td>

<td></td> <td></td> </tr> <tr class="t-dcl ">

<td >
template< class InputIt, class OutputIt, class T >

OutputIt replace_copy( InputIt first, InputIt last, OutputIt d_first,

                       const T& old_value, const T& new_value );
</td>

<td > (1) </td> <td class="t-dcl-nopad"> </td> </tr> <tr class="t-dcl ">

<td >
template< class InputIt, class OutputIt, class UnaryPredicate, class T >

OutputIt replace_copy_if( InputIt first, InputIt last, OutputIt d_first,

                          UnaryPredicate p, const T& new_value );
</td>

<td > (2) </td> <td class="t-dcl-nopad"> </td> </tr> Template:ddcl list end

Copies the all elements from the range [first, last) to another range beginning at d_first replacing all elements satisfying specific criteria with new_value. The first version replaces the elements that are equal to old_value, the second version replaces elements for which predicate p returns true. The source and destination ranges cannot overlap.

Contents

Parameters

first, last - the range of elements to copy
d_first - the beginning of the destination range
old_value - the value of elements to replace
p - unary predicate which returns ​true if the element value should be replaced.

The expression p(v) must be convertible to bool for every argument v of type (possibly const) VT, where VT is the value type of InputIt, regardless of value category, and must not modify v. Thus, a parameter type of VT&is not allowed, nor is VT unless for VT a move is equivalent to a copy(since C++11). ​

new_value - the value to use as replacement
Type requirements
-
InputIt must meet the requirements of LegacyInputIterator.
-
OutputIt must meet the requirements of LegacyOutputIterator.

Return value

Iterator to the element past the last element copied.

Complexity

Exactly last - first applications of the predicate.

Possible implementation

First version
template<class InputIt, class OutputIt, class T>
OutputIt replace_copy(InputIt first, InputIt last, OutputIt d_first,
                      const T& old_value, const T& new_value)
{
    for (; first != last; ++first) {
        *d_first++ = (*first == old_value) ? new_value : *first;
    }
    return d_first;
}
Second version
template<class InputIt, class OutputIt, 
         class UnaryPredicate, class T>
OutputIt replace_copy_if(InputIt first, InputIt last, OutputIt d_first,
                         UnaryPredicate p, const T& new_value)
{
    for (; first != last; ++first) {
        *d_first++ = (p( *first ) ? new_value : *first;
    }
    return d_first;
}

Example

The following copy prints a vector, replacing all values over 5 with 99 on the fly.

#include <algorithm>
#include <vector>
#include <iostream>
#include <iterator>
#include <functional>
 
int main()
{
    std::vector<int> v{5, 7, 4, 2, 8, 6, 1, 9, 0, 3};
    std::replace_copy_if(v.begin(), v.end(),
                         std::ostream_iterator<int>(std::cout, " "),
                         [](int n){return n > 5;}, 99);
    std::cout << '\n';
}

Output:

5 99 4 2 99 99 1 99 0 3

See also

Template:cpp/algorithm/dcl list remove