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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::forward_list::unique - std::forward_list::unique

Synopsis
	  void unique();				 (since	C++11)
							 (until	C++20)
	  size_type unique();				 (since	C++20)
	  template<  class BinaryPredicate >	  (1)			(since
       C++11)
	  void unique( BinaryPredicate p );	     (2)		(until
       C++20)
	  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
	      forward_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 std::distance(begin(), end())	- 1 comparisons	 of  the  ele-
       ments, 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 <forward_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::forward_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::forward_list::unique(3)

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

home | help