std::unique_copy
Defined in header
<algorithm>
|
||
template< class InputIt, class OutputIt >
OutputIt unique_copy( InputIt first, InputIt last, |
(1) | |
template< class InputIt, class OutputIt, class BinaryPredicate >
OutputIt unique_copy( InputIt first, InputIt last, |
(2) | |
Copies the elements from the range [first, last)
, to another range beginning at d_first
in such a way that there are no consecutive equal elements. Only the first element of each group of equal elements is copied. The first version uses operator==
to compare the elements, the second version uses the given binary predicate p
.
Contents |
[edit] Parameters
first, last | - | the range of elements to process |
d_first | - | the beginning of the destination range |
p | - | binary predicate which returns true if the elements should be treated as equal. The signature of the predicate function should be equivalent to the following: bool pred(const Type1 &a, const Type2 &b); The signature does not need to have const &, but the function must not modify the objects passed to it. |
Type requirements | ||
-
InputIt must meet the requirements of InputIterator .
|
||
-
OutputIt must meet the requirements of OutputIterator .
|
||
-The type of dereferenced InputIt must meet the requirements of CopyAssignable .
|
||
-The type of dereferenced InputIt must meet the requirements of CopyConstructible . if neither InputIt nor OutputIt satisfies ForwardIterator
|
[edit] Return value
Output iterator to the element past the last written element
[edit] Possible implementation
First version |
---|
template<class ForwardIt, class OutputIt> ForwardIt unique_copy(ForwardIt first, ForwardIt last, OutputIt d_first) { if (first == last) return d_first; *d_first = *first; while (++first != last) { if (!(*d_first == *first)) { *(++d_first) = *first; } } return ++d_first; } |
Second version |
template<class ForwardIt, class OutputIt, class BinaryPredicate> ForwardIt unique_copy(ForwardIt first, ForwardIt last, OutputIt d_first, BinaryPredicate p) { if (first == last) return d_first; *d_first = *first; while (++first != last) { if (!p(*result, *first)) { *(++d_first) = *first; } } return ++d_first; } |
[edit] Example
The following program trims all multiple consecutive spaces in a const string and prints the result
#include <string> #include <iostream> #include <algorithm> #include <iterator> int main() { std::string s1 = "The string with many spaces!"; std::cout << "before: " << s1 << '\n'; std::string s2; std::unique_copy(s1.begin(), s1.end(), std::back_inserter(s2), [](char c1, char c2){ return c1 == ' ' && c2 == ' '; }); std::cout << "after: " << s2 << '\n'; }
Output:
before: The string with many spaces! after: The string with many spaces!
[edit] Complexity
linear in the distance between first
and last
[edit] See also
finds the first two adjacent items that are equal (or satisfy a given predicate) (function template) |
|
removes consecutive duplicate elements in a range (function template) |