Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::list::unique(3)	      C++ Standard Libary	  std::list::unique(3)

NAME
       std::list::unique - std::list::unique

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

	  Removes  all consecutive duplicate elements from the container. Only
       the first
	  element in each group	of equal elements is left. The behavior	is un-
       defined 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
	      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);

	  p - 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

See also
	  unique removes consecutive duplicate elements	in a range
		 (function template)

http://cppreference.com		  2022.07.31		  std::list::unique(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::list::unique&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help