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

	(1)
void unique();			(until C++20)
size_type unique();			(since C++20)
		(2)
template< class BinaryPredicate > void unique( BinaryPredicate p );				(until C++20)
template< class BinaryPredicate > size_type unique( BinaryPredicate p );				(since C++20)

Removes all consecutive duplicate elements from the container. Only the first element in each group of equal elements is left. The behavior is undefined if the selected comparator does not establish an equivalence relation.

1) Uses operator== to compare the elements.

2) Uses the given binary predicate p to compare the elements.

Parameters

p

-

binary predicate which returns true if the elements should be treated as equal.

The signature of the predicate function should be equivalent to the following:

bool pred(const Type1 &a, const Type2 &b);

While the signature does not need to have const &, the function must not modify the objects passed to it and must be able to accept all values of type (possibly const) Type1 and Type2 regardless of value category (thus, Type1 & is not allowed, nor is Type1 unless for Type1 a move is equivalent to a copy (since C++11)).
The types Type1 and Type2 must be such that an object of type list<T,Allocator>::const_iterator can be dereferenced and then implicitly converted to both of them.

Return value

(none)	(until C++20)
The number of elements removed.	(since C++20)

Complexity

Exactly size() - 1 comparisons of the elements, if the container is not empty. Otherwise, no comparison is performed.

Notes

Feature-test macro:	`__cpp_lib_list_remove_return_type`

Example

Run this code

#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);
  const auto count1 = c.unique();
  print("After unique(): ", c);
  std::cout << count1 << " elements were removed\n";
 
  c = {1, 2, 12, 23, 3, 2, 51, 1, 2, 2};
  print("Before unique(pred):", c);
  const auto count2 = c.unique([mod=10](int x, int y) {
      return (x % mod) == (y % mod);
  });
  print("After unique(pred): ", c);
  std::cout << count2 << " elements were removed\n";
}

Output:

Before unique(): 1 2 2 3 3 2 1 1 2
After unique():  1 2 3 2 1 2
3 elements were removed
Before unique(pred): 1 2 12 23 3 2 51 1 2 2
After unique(pred):  1 2 23 2 51 2
4 elements were removed

Compiler support
Freestanding and hosted
Language
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

Sequence
array (C++11)
vector
deque
forward_list (C++11)
list
Associative
set
multiset
map
multimap
Unordered associative
unordered_set (C++11)
unordered_multiset (C++11)
unordered_map (C++11)
unordered_multimap (C++11)
Adaptors
stack
queue
priority_queue
Views
span (C++20)

Member functions
list::list
list::~list
list::operator=
list::assign
list::get_allocator
Element access
list::front
list::back
Iterators
list::beginlist::cbegin (C++11)
list::endlist::cend (C++11)
list::rbeginlist::crbegin (C++11)
list::rendlist::crend (C++11)
Capacity
list::empty
list::size
list::max_size
Modifiers
list::clear
list::insert
list::emplace (C++11)
list::erase
list::push_front
list::emplace_front (C++11)
list::pop_front
list::push_back
list::emplace_back (C++11)
list::pop_back
list::resize
list::swap
Operations
list::merge
list::splice
list::removelist::remove_if
list::reverse
list::unique
list::sort
Non-member functions
std::swap
eraseerase_if (C++20)(C++20)
operator==operator!=operator<operator>operator<=operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)
Deduction guides(C++17)