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) |