# std::list<T,Allocator>::unique

< cpp‎ | container‎ | list

| (1) |
void unique(); |  | (C++20 前)
size_type unique(); |  | (C++20 起)
| (2) |
template< class BinaryPredicate > void unique( BinaryPredicate p ); |  | (C++20 前)
template< class BinaryPredicate > size_type unique( BinaryPredicate p ); |  | (C++20 起)

从容器移除所有相继的重复元素。只留下相等元素组中的第一个元素。若选择的比较器不建立等价关系则行为未定义。

1) 用 operator== 比较元素。
2) 用二元谓词 `p` 比较元素。

### 参数

p | - | 若元素应被当做相等则返回 ​true 的二元谓词。 谓词函数的签名应等价于如下： bool pred(const Type1 &a, const Type2 &b); 虽然签名不必有 const & ，函数也不能修改传递给它的对象，而且必须接受（可为 const 的）类型 `Type1` 与 `Type2` 的值，无关乎值类别（从而不允许 Type1 & ，亦不允许 Type1 ，除非 `Type1` 的移动等价于复制 (C++11 起)）。 类型 Type1 与 Type2 必须使得 list<T,Allocator>::const_iterator 类型的对象能在解引用后隐式转换到这两个类型。 ​

### 返回值

（无） | (C++20 前)
移除的元素数。 | (C++20 起)

### 复杂度

若容器非空则准确比较元素 size() - 1 次。否则不进行比较。

### 示例

    #include <iostream>
    #include <list>

    auto print = [](auto remark, auto const& container) {
      std::cout << remark;
      for (auto const& val : container)
        std::cout << ' ' << val;
      std::cout << '\n';
    };

    int main()
    {
      std::list<int> c = {1, 2, 2, 3, 3, 2, 1, 1, 2};
      print("Before unique():", c);
      c.unique();
      print("After  unique():", c);

      c = {1, 2, 12, 23, 3, 2, 51, 1, 2};
      print("Before unique(pred):", c);
      c.unique([mod=10](int x, int y) { return (x % mod) == (y % mod); });
      print("After  unique(pred):", c);
    }

输出：

    Before unique(): 1 2 2 3 3 2 1 1 2
    After  unique(): 1 2 3 2 1 2
    Before unique(pred): 1 2 12 23 3 2 51 1 2
    After  unique(pred): 1 2 23 2 51 2

### 参阅

unique | 移除范围内的连续重复元素 (函数模板)