unique_copy-c和c++中文资料站

C&C++标准库

std::

unique_copy

函数模板 <algorithm>

equality (1)

template <class InputIterator, class OutputIterator>
  OutputIterator unique_copy (InputIterator first, InputIterator last,
                              OutputIterator result);

predicate (2)

template <class InputIterator, class OutputIterator, class BinaryPredicate>
  OutputIterator unique_copy (InputIterator first, InputIterator last,
                              OutputIterator result, BinaryPredicate pred);/pre>

复制范围内非连续重复的项

将范围[first,last)中的元素复制到从result开始的范围，除了连续的重复元素(与前面元素比较相等的元素)。

只复制范围[first,last)内每一组相等元素中的第一个元素。

该函数使用operator==来比较元素(或版本(2)中的pred)。

这个函数模板的行为相当于:

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的值。返回的值表明两个参数是否相等(如果为真，它们是相等的，保留其中一个)。
函数不能修改它的任何参数。
它可以是函数指针，也可以是函数对象。

范围不得重叠。

☉ 返回值

指向复制范围末尾的迭代器，该范围不包含连续的重复项。

☣ 示例

// 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	检查并覆盖范围中的值(函数模板)