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

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

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)

Atomic operations library (C++11)

Thread support library (C++11)

Technical specifications

Symbols index

External libraries

 

Containers library

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)

 

std::list

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)

 

	(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.

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);
  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);
}

Output:

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

See also

unique

removes consecutive duplicate elements in a range (function template)