Standard Template Library Programmer's Guide

• There is enough space in the output range to store the copied values. That is, if there are n elements in [first, last) that do not satisfy pred, then [result, result+n) is a valid range.

• result is not an iterator in the range [first, last) .

Complexity

Linear. Exactly last – first applications of pred , and at most last – first assignments.

Example

Fill a vector with the nonnegative elements of another vector.

vector<int> V1;
V.push_back(-2);
V.push_back(0);
V.push_back(-1);
V.push_back(0);
V.push_back(1);
V.push_back(2);
vector<int> V2; remove_copy_if(V1.begin(), V1.end(), back_inserter(V2), bind2nd (less<int>(), 0));

See also

copy, remove, remove_if, remove_copy, unique, unique_copy.

unique

Category: algorithms

Component type: function

Prototype

Unique is an overloaded name; there are actually two unique functions.

template <class ForwardIterator>
ForwardIterator unique(ForwardIterator first, ForwardIterator last);
template <class ForwardIterator, class BinaryPredicate>
ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate binary_pred);

Description

Every time a consecutive group of duplicate elements appears in the range [first, last) , the algorithm unique removes all but the first element. That is, unique returns an iterator new_last such that the range [first, new_last) contains no two consecutive elements that are duplicates. [1] The iterators in the range [new_last, last) are all still dereferenceable, but the elements that they point to are unspecified. Unique is stable, meaning that the relative order of elements that are not removed is unchanged.

The reason there are two different versions of unique is that there are two different definitions of what it means for a consecutive group of elements to be duplicates. In the first version, the test is simple equality: the elements in a range [f, l) are duplicates if, for every iterator i in the range, either i == f or else *i == *(i-1) . In the second, the test is an arbitrary Binary Predicate binary_pred: the elements in [f, l) are duplicates if, for every iterator i in the range, either i == f or else binary_pred(*i, *(i-1)) is true. [2]

Definition

Defined in the standard header algorithm, and in the nonstandard backward-compatibility header algo.h.

Requirements on types

For the first version:

• ForwardIterator is a model of Forward Iterator.

• ForwardIterator is mutable.

• ForwardIterator's value type is Equality Comparable.

For the second version:

• ForwardIterator is a model of Forward Iterator.

• ForwardIterator is mutable.

• BinaryPredicate is a model of Binary Predicate. [3]

• ForwardIterator's value type is convertible to BinaryPredicate's first argument type and to BinaryPredicate 's second argument type.

Preconditions

• [first, last) is a valid range.

Complexity

Linear. Exactly (last – first) – 1 applications of operator== (in the case of the first version of unique ) or of binary_pred (in the case of the second version).

Example

Remove duplicates from consecutive groups of equal int s.

vector<int> V;
V.push_back(1);
V.push_back(3);
V.push_back(3);
V.push_back(3);
V.push_back(2);
V.push_back(2);
V.push_back(1);
vector<int>::iterator new_end = unique(V.begin(), V.end());
copy(V.begin(), new_end, ostream_iterator<int>(cout, ' '));
// The output it '1 3 2 1'.

Remove all duplicates from a vector of char s, ignoring case. First sort the vector, then remove duplicates from consecutive groups.

inline bool eq_nocase(char c1, char c2) { return tolower(c1) == tolower(c2); }
inline bool lt_nocase(char c1, char c2) { return tolower(c1) < tolower(c2); }
int main() {
 const char init[] = 'The Standard Template Library';
 vector<char> V(init, init + sizeof(init));
 sort(V.begin(), V.end(), lt_nocase);
 copy(V.begin(), V.end(), ostream_iterator<char>(cout));