public member function
<forward_list>

std::forward_list::unique

(1)
void unique();
(2)
template <class BinaryPredicate>  void unique (BinaryPredicate binary_pred);
移除重复的值
无参数的版本(1),会移除容器中所有连续相等元素组中除第一个元素外的所有元素。

请注意,元素只有在与紧邻的前一个元素相等时才会被从forward_list容器中移除。因此,此函数对于已排序的列表特别有用。

第二个版本(2),接受一个特定的比较函数作为参数,该函数用于确定元素的“唯一性”。实际上,可以实现任何行为(不只是相等比较),但请注意,该函数将调用binary_pred(*i,*(i-1))对于所有元素对(其中i是指向某个元素的迭代器,从第二个元素开始),如果谓词返回itrue则从forward_list中移除元素。.

被移除的元素将被销毁。

参数

binary_pred
二元谓词,它接受与forward_list中包含的元素类型相同的两个值,如果则从forward_list中移除元素。should remove the element passed as first argument from the container, and false otherwise.
这应该是一个函数指针或函数对象。

返回值



示例

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
37
38
39
// forward_list::unique
#include <iostream>
#include <cmath>
#include <forward_list>

// a binary predicate implemented as a function:
bool same_integral_part (double first, double second)
{ return ( int(first)==int(second) ); }

// a binary predicate implemented as a class:
class is_near_class
{
public:
  bool operator() (double first, double second)
  { return (fabs(first-second)<5.0); }
} is_near_object;

int main ()
{

  std::forward_list<double> mylist = { 15.2, 73.0, 3.14, 15.85, 69.5,
                                       73.0, 3.99, 15.2, 69.2,  18.5 };

  mylist.sort();                       //   3.14,  3.99, 15.2, 15.2, 15.85
                                       //  18.5,  69.2,  69.5, 73.0, 73.0

  mylist.unique();                     //   3.14,  3.99, 15.2, 15.85
                                       //  18.5,  69.2,  69.5, 73.0

  mylist.unique (same_integral_part);  //  3.14, 15.2, 18.5,  69.2, 73.0

  mylist.unique (is_near_object);      //  3.14, 15.2, 69.2

  std::cout << "mylist contains:";
  for (double& x: mylist) std::cout << ' ' << x;
  std::cout << '\n';

  return 0;
}

输出
mylist contains: 3.14 15.2 69.2


复杂度

线性复杂度,与容器大小减一成正比。

迭代器有效性

指向被函数移除的元素的迭代器、指针和引用将失效。
所有其他迭代器、指针和引用保持其有效性。

数据竞争

容器将被修改。
被移除的元素将被修改。并发访问或修改其他元素是安全的,但遍历容器则不是。

异常安全

如果binary_pred或元素的比较被保证不会抛出异常,则函数永远不会抛出异常(无抛出保证)。
否则,如果抛出异常,容器将保持在有效状态(基本保证)。

另见