std::unique

equality (1)	template <class ForwardIterator> ForwardIterator unique (ForwardIterator first, ForwardIterator last);
predicate (2)	template <class ForwardIterator, class BinaryPredicate> ForwardIterator unique (ForwardIterator first, ForwardIterator last, BinaryPredicate pred);

equality (1)

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

predicate (2)

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

Remove consecutive duplicates in range

Removes all but the first element from every consecutive group of equivalent elements in the range[first,last).

The function cannot alter the properties of the object containing the range of elements (i.e., it cannot alter the size of an array or a container): The removal is done by replacing the duplicate elements by the next element that is not a duplicate, and signaling the new size of the shortened range by returning an iterator to the element that should be considered its newpast-the-end element.

The relative order of the elements not removed is preserved, while the elements between the returned iterator andlast are left in a valid but unspecified state.

The function usesoperator== to compare the pairs of elements (orpred, in version(2)).

The behavior of this function template is equivalent to:

template <class ForwardIterator>  ForwardIterator unique (ForwardIterator first, ForwardIterator last){if (first==last)return last;  ForwardIterator result = first;while (++first != last)  {if (!(*result == *first))// or: if (!pred(*result,*first)) for version (2)      *(++result)=*first;  }return ++result;}

Parameters

first, last: Forward iterators to the initial and final positions of the sequence ofmove-assignable elements. The range used is[first,last), which contains all the elements betweenfirst andlast, including the element pointed byfirst but not the element pointed bylast.
pred: Binary function that accepts two elements in the range as argument, and returns a value convertible tobool. The value returned indicates whether both arguments are considered equivalent (iftrue, they are equivalent and one of them is removed).
The function shall not modify any of its arguments.
This can either be a function pointer or a function object.

Return value

An iterator to the element that follows the last element not removed.
The range betweenfirst and this iterator includes all the elements in the sequence that were not considered duplicates.

Example

// unique algorithm example#include <iostream>// std::cout#include <algorithm>// std::unique, std::distance#include <vector>// std::vectorbool myfunction (int i,int j) {return (i==j);}int main () {int myints[] = {10,20,20,20,30,30,20,20,10};// 10 20 20 20 30 30 20 20 10  std::vector<int> myvector (myints,myints+9);// using default comparison:  std::vector<int>::iterator it;  it = std::unique (myvector.begin(), myvector.end());// 10 20 30 20 10 ?  ?  ?  ?//                ^  myvector.resize( std::distance(myvector.begin(),it) );// 10 20 30 20 10// using predicate comparison:  std::unique (myvector.begin(), myvector.end(), myfunction);// (no changes)// print out content:  std::cout <<"myvector contains:";for (it=myvector.begin(); it!=myvector.end(); ++it)    std::cout <<' ' << *it;  std::cout <<'\n';return 0;}

Output:

myvector contains: 10 20 30 20 10

Complexity

For non-empty ranges, linear in one less than thedistance betweenfirst andlast: Compares each pair of consecutive elements, and possibly performs assignments on some of them.

Data races

The objects in the range[first,last) are accessed and potentially modified.

Exceptions

Throws if any ofpred, the element comparisons, the element assignments or the operations on iterators throws.
Note that invalid arguments causeundefined behavior.

Movatterモバイル変換

C++

Reference

C library:

Containers:

Input/Output:

Multi-threading:

Other:

<algorithm>