NAME

std::remove_copy,std::remove_copy_if - std::remove_copy,std::remove_copy_if

Synopsis

Defined in header <algorithm>
template< class InputIt, class OutputIt, class T
>

OutputIt remove_copy( InputIt first, InputIt (until C++20)
last, OutputIt d_first,

const T& value );
template< class InputIt, class OutputIt, class T
>

constexpr OutputIt remove_copy( InputIt first, (since C++20)
InputIt last, OutputIt d_first,

const T& value );
template< class ExecutionPolicy, class
ForwardIt1, class ForwardIt2, class T >

ForwardIt2 remove_copy( ExecutionPolicy&& (2) (since C++17)
policy, ForwardIt1 first, ForwardIt1 last,

ForwardIt2 d_first, const T& value );
template< class InputIt, class OutputIt, class (1)
UnaryPredicate >

OutputIt remove_copy_if( InputIt first, InputIt (until C++20)
last, OutputIt d_first,

UnaryPredicate p );
template< class InputIt, class OutputIt, class
UnaryPredicate >

constexpr OutputIt remove_copy_if( InputIt (3) (since C++20)
first, InputIt last, OutputIt d_first,

UnaryPredicate p );
template< class ExecutionPolicy, class
ForwardIt1, class ForwardIt2, class
UnaryPredicate >
(4) (since C++17)
ForwardIt2 remove_copy_if( ExecutionPolicy&&
policy, ForwardIt1 first, ForwardIt1 last,

ForwardIt2 d_first, UnaryPredicate p );

Copies elements from the range [first, last), to another range beginning at d_first,
omitting the elements which satisfy specific criteria. Source and destination ranges
cannot overlap.

1) Ignores all elements that are equal to value.
3) Ignores all elements for which predicate p returns true.
2,4) Same as (1,3), but executed according to policy. These overloads do not
participate in overload resolution unless
std::is_execution_policy_v<std::decay_t<ExecutionPolicy>>
(until C++20)
std::is_execution_policy_v<std::remove_cvref_t<ExecutionPolicy>>
(since C++20) is true.

Parameters

first, last - the range of elements to copy
d_first - the beginning of the destination range.
value - the value of the elements not to copy
policy - the execution policy to use. See execution policy for details.

Type requirements

-
InputIt must meet the requirements of LegacyInputIterator.
-
OutputIt must meet the requirements of LegacyOutputIterator.
-
ForwardIt1, ForwardIt2 must meet the requirements of LegacyForwardIterator.
-
UnaryPredicate must meet the requirements of Predicate.

Return value

Iterator to the element past the last element copied.

Complexity

Exactly std::distance(first, last) applications of the predicate.

For the overloads with an ExecutionPolicy, there may be a performance cost if
ForwardIt1's value_type is not MoveConstructible.

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
and ExecutionPolicy is one of the standard policies, std::terminate is called.
For any other ExecutionPolicy, the behavior is implementation-defined.
* If the algorithm fails to allocate memory, std::bad_alloc is thrown.

Possible implementation

First version

template<class InputIt, class OutputIt, class T>
OutputIt remove_copy(InputIt first, InputIt last,
OutputIt d_first, const T& value)
{
for (; first != last; ++first) {
if (!(*first == value)) {
*d_first++ = *first;
}
}
return d_first;
}

Second version

template<class InputIt, class OutputIt, class UnaryPredicate>
OutputIt remove_copy_if(InputIt first, InputIt last,
OutputIt d_first, UnaryPredicate p)
{
for (; first != last; ++first) {
if (!p(*first)) {
*d_first++ = *first;
}
}
return d_first;
}

Example

The following code outputs a string while erasing the hash characters '#' on the
fly.

// Run this code

#include <algorithm>
#include <iterator>
#include <string>
#include <iostream>
#include <iomanip>
int main()
{
std::string str = "#Return #Value #Optimization";
std::cout << "before: " << std::quoted(str) << "\n";

std::cout << "after: \"";
std::remove_copy(str.begin(), str.end(),
std::ostream_iterator<char>(std::cout), '#');
std::cout << "\"\n";
}

Output:

before: "#Return #Value #Optimization"
after: "Return Value Optimization"