| Defined in header <algorithm> | ||
|---|---|---|
template< class InputIt, class OutputIt1,
class OutputIt2, class UnaryPredicate >
std::pair<OutputIt1, OutputIt2>
partition_copy( InputIt first, InputIt last,
OutputIt1 d_first_true, OutputIt2 d_first_false,
UnaryPredicate p ); | (since C++11) |
Copies the elements from the range [first, last) to two different ranges depending on the value returned by the predicate p. The elements, that satisfy the predicate p, are copied to the range beginning at d_first_true. The rest of the elements are copied to the range beginning at d_first_false.
The behavior is undefined if the input range overlaps either of the output ranges.
Parameters
| first, last | - | the range of elements to sort |
| d_first_true | - | the beginning of the output range for the elements that satisfy p |
| d_first_false | - | the beginning of the output range for the elements that do not satisfy p |
| p | - | unary predicate which returns true if the element should be placed in d_first_true. The signature of the predicate function should be equivalent to the following:
The signature does not need to have |
| Type requirements | ||
- InputIt must meet the requirements of InputIterator. | ||
-The type of dereferenced InputIt must meet the requirements of CopyAssignable. | ||
- OutputIt1 must meet the requirements of OutputIterator. | ||
- OutputIt2 must meet the requirements of OutputIterator. | ||
- UnaryPredicate must meet the requirements of Predicate. | ||
Return value
A pair constructed from the iterator to the end of the d_first_true range and the iterator to the end of the d_first_false range.
Complexity
Exactly distance(first, last) applications of p.
Possible implementation
template<class InputIt, class OutputIt1,
class OutputIt2, class UnaryPredicate>
std::pair<OutputIt1, OutputIt2>
partition_copy(InputIt first, InputIt last,
OutputIt1 d_first_true, OutputIt2 d_first_false,
UnaryPredicate p)
{
while (first != last) {
if (p(*first)) {
*d_first_true = *first;
++d_first_true;
} else {
*d_first_false = *first;
++d_first_false;
}
++first;
}
return std::pair<OutputIt1, OutputIt2>(d_first_true, d_first_false);
} |
Example
#include <iostream>
#include <algorithm>
#include <utility>
int main()
{
int arr [10] = {1,2,3,4,5,6,7,8,9,10};
int true_arr [5] = {0};
int false_arr [5] = {0};
std::partition_copy(std::begin(arr), std::end(arr), std::begin(true_arr),std::begin(false_arr),
[] (int i) {return i > 5;});
std::cout << "true_arr: ";
for (auto it = std::begin(true_arr); it != std::end(true_arr); ++it) {
std::cout << *it << ' ';
}
std::cout << '\n';
std::cout << "false_arr: ";
for (auto it = std::begin(false_arr); it != std::end(false_arr); ++it) {
std::cout << *it << ' ';
}
std::cout << '\n';
return 0;
}Output:
true_arr: 6 7 8 9 10 false_arr: 1 2 3 4 5
See also
| divides a range of elements into two groups (function template) | |
| divides elements into two groups while preserving their relative order (function template) | |
| std::experimental::parallel::partition_copy
(parallelism TS) | parallelized version of std::partition_copy (function template) |
Please login to continue.