C++

参考

<algorithm>

函数模板
<algorithm>

std::unique_copy

相等 (1)
template <class InputIterator, class OutputIterator>  OutputIterator unique_copy (InputIterator first, InputIterator last,                              OutputIterator result);
谓词 (2)
template <class InputIterator, class OutputIterator, class BinaryPredicate>  OutputIterator unique_copy (InputIterator first, InputIterator last,                              OutputIterator result, BinaryPredicate pred);
复制范围并移除重复项
将范围 [first,last) 中的元素复制到以 result 开头的范围中，但会跳过连续的重复项（与前一个元素相等的元素）。

仅复制范围 [first,last) 中每个连续等价元素组的第一个元素。

元素之间的比较是通过应用 operator== 或模板参数 pred（用于第二个版本）来实现的。

此函数模板的行为等同于
1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template <class InputIterator, class OutputIterator>
  OutputIterator unique_copy (InputIterator first, InputIterator last,
                              OutputIterator result)
{
  if (first==last) return result;

  *result = *first;
  while (++first != last) {
    typename iterator_traits<InputIterator>::value_type val = *first;
    if (!(*result == val))   // or: if (!pred(*result,val)) for version (2)
      *(++result)=val;
  }
  return ++result;
}

参数

first, last
前向迭代器，指向序列的起始和结束位置。使用的范围是 [first,last)，其中包含 first 和 last 之间的所有元素，包括 first 指向的元素，但不包括 last 指向的元素。
如果 InputIterator 是一个单次遍历迭代器，那么它指向的类型必须是可复制构造且可复制赋值的。
result
输出迭代器，指向结果范围的起始位置。
被指向的类型应支持被赋值为范围 [first,last) 中某个元素的值。
pred
二元函数，接受范围内的两个元素作为参数，并返回一个可转换为 bool 的值。返回的值指示两个参数是否被视为等价（如果为 true，则它们等价，其中一个将被移除）。
该函数不得修改其任何参数。
这可以是指针函数，也可以是函数对象。

这些范围不应重叠。

返回值

一个指向已复制范围结束位置的迭代器，该范围不包含连续的重复项。

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
 
// unique_copy example
#include <iostream>     // std::cout
#include <algorithm>    // std::unique_copy, std::sort, std::distance
#include <vector>       // std::vector

bool myfunction (int i, int j) {
  return (i==j);
}

int main () {
  int myints[] = {10,20,20,20,30,30,20,20,10};
  std::vector<int> myvector (9);                            // 0  0  0  0  0  0  0  0  0

  // using default comparison:
  std::vector<int>::iterator it;
  it=std::unique_copy (myints,myints+9,myvector.begin());   // 10 20 30 20 10 0  0  0  0
                                                            //                ^

  std::sort (myvector.begin(),it);                          // 10 10 20 20 30 0  0  0  0
                                                            //                ^

  // using predicate comparison:
  it=std::unique_copy (myvector.begin(), it, myvector.begin(), myfunction);
                                                            // 10 20 30 20 30 0  0  0  0
                                                            //          ^

  myvector.resize( std::distance(myvector.begin(),it) );    // 10 20 30

  // print out content:
  std::cout << "myvector contains:";
  for (it=myvector.begin(); it!=myvector.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

输出
myvector contains: 10 20 30


复杂度

最多线性于 first 和 last 之间的距离：比较每对元素，并对不匹配的元素执行赋值操作。

数据竞争

访问范围 [first,last) 中的对象。
修改 result 和返回的迭代器之间的范围内的对象。

异常

如果 pred、元素比较、元素赋值或迭代器操作抛出异常，则本函数也抛出异常。
请注意，无效参数会导致未定义行为。

另见

unique
移除范围中的连续重复项 （函数模板）
adjacent_find
在范围中查找相等的相邻元素 （函数模板）
remove
从范围中移除值 （函数模板）
remove_if
从范围中移除元素 （函数模板）