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

FreeBSD Manual Pages

  
 
  

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

NAME
       std::flat_multiset - std::flat_multiset

Synopsis
	  Defined in header <flat_set>
	  template<

	      class Key,
	      class Compare = std::less<Key>,	     (since C++23)
	      class KeyContainer = std::vector<Key>

	  > class flat_multiset;

	  The  flat multiset is	a container adaptor that gives the functional-
       ity of an
	  associative container	that stores a sorted set of  objects  of  type
       Key. Unlike
	  std::flat_set,  multiple  keys  with	equivalent values are allowed.
       Sorting is done
	  using	the key	comparison function Compare.

	  The class template flat_multiset acts	as a wrapper to	the underlying
       sorted
	  container passed as object of	type KeyContainer.

	  Everywhere the  standard  library  uses  the	Compare	 requirements,
       uniqueness is
	  determined  by  using	 the equivalence relation. Informally, two ob-
       jects a and b are
	  considered equivalent	if  neither  compares  less  than  the	other:
       !comp(a,	b) &&
	  !comp(b, a).

	  std::flat_multiset  meets the	requirements of	Container, Reversible-
       Container,
	  optional container requirements, and all  requirements  of  Associa-
       tiveContainer
	  (including logarithmic search	complexity), except that:

	    * requirements related to nodes are	not applicable,
	    * iterator invalidation requirements differ,
	    * the complexity of	insertion and erasure operations is linear.

	  A flat multiset supports most	AssociativeContainer's operations that
       use equal keys.

Template parameters
	  Key		- The type of the stored elements. The program is ill-
       formed if Key is
			 not the same type as KeyContainer::value_type.
	  Compare      - A Compare type	providing a strict weak	ordering.
			 The type of the underlying SequenceContainer to store
       the elements.
			 The iterators of such container should	satisfy
	  KeyContainer - LegacyRandomAccessIterator or model random_access_it-
       erator.

			 The standard containers  std::vector  and  std::deque
       satisfy these
			 requirements.

Member types
	  Member type		 Definition
	  container_type	 KeyContainer
	  key_type		 Key
	  value_type		 Key
	  key_compare		 Compare
	  value_compare		 Compare
	  reference		 value_type&
	  const_reference	 const value_type&
	  size_type		 typename KeyContainer::size_type
	  difference_type	 typename KeyContainer::difference_type
	  iterator		  implementation-defined LegacyRandomAccessIt-
       erator and
				 random_access_iterator	to value_type
	  const_iterator	 implementation-defined	 LegacyRandomAccessIt-
       erator and
				 random_access_iterator	to const value_type
	  reverse_iterator	 std::reverse_iterator<iterator>
	  const_reverse_iterator std::reverse_iterator<const_iterator>

Member objects
	  Member name	    Definition
	  c (private)	    the	underlying container of	container_type
			    (exposition-only member object*)
	  compare (private) the	comparison function object of type key_compare
			    (exposition-only member object*)

Member functions
	  constructor		constructs the flat_multiset
				(public	member function)
	  destructor		 destroys every	element	of the container adap-
       tor
	  (implicitly declared)	(public	member function)
	  operator=		assigns	values to the container	adaptor
				(public	member function)

Iterators
	  begin			returns	an iterator to the beginning
	  cbegin		(public	member function)
	  end			returns	an iterator to the end
	  cend			(public	member function)
	  rbegin		returns	a reverse iterator to the beginning
	  crbegin		(public	member function)
	  rend			returns	a reverse iterator to the end
	  crend			(public	member function)

Capacity
	  empty			checks whether the container adaptor is	empty
				(public	member function)
	  size			returns	the number of elements
				(public	member function)
	  max_size		returns	the maximum possible  number  of  ele-
       ments
				(public	member function)

Modifiers
	  emplace		constructs element in-place
				(public	member function)
	  emplace_hint		constructs elements in-place using a hint
				(public	member function)
	  insert		inserts	elements
				(public	member function)
	  insert_range		inserts	a range	of elements
				(public	member function)
	  extract		extracts the underlying	container
				(public	member function)
	  replace		replaces the underlying	container
				(public	member function)
	  erase			erases elements
				(public	member function)
	  swap			swaps the contents
				(public	member function)
	  clear			clears the contents
				(public	member function)

Lookup
	  find			finds element with specific key
				(public	member function)
	  count			 returns  the number of	elements matching spe-
       cific key
				(public	member function)
	  contains		checks if the container	contains element  with
       specific	key
				(public	member function)
				returns	 an  iterator to the first element not
       less than the
	  lower_bound		given key
				(public	member function)
				returns	 an  iterator  to  the	first  element
       greater than the
	  upper_bound		given key
				(public	member function)
	  equal_range		 returns range of elements matching a specific
       key
				(public	member function)

Observers
	  key_comp		returns	the function that compares keys
				(public	member function)
				returns	the function that compares keys	in ob-
       jects of	type
	  value_comp		value_type
				(public	member function)

Non-member functions
	  operator==			lexicographically compares the	values
       of two
	  operator<=>			flat_multisets
	  (C++23)			(function template)
	  std::swap(std::flat_multiset)	specializes the	std::swap algorithm
	  (C++23)			(function template)
	  erase_if(std::flat_multiset)	 erases	 all  elements satisfying spe-
       cific criteria
	  (C++23)			(function template)

Helper classes
	  std::uses_allocator<std::flat_multiset>	specializes	   the
       std::uses_allocator type
	  (C++23)				  trait
						  (class  template specializa-
       tion)

	  Tags

	  sorted_equivalent   indicates	that elements of a  range  are	sorted
       (uniqueness is not
	  sorted_equivalent_t required)
	  (C++23)	      (tag)

	  Deduction guides

Notes
	  The  member  types iterator and const_iterator may be	aliases	to the
       same type. This
	  means	defining a pair	of function overloads using the	two  types  as
       parameter types
	  may  violate	the One	Definition Rule. Since iterator	is convertible
       to
	  const_iterator, a single function with a const_iterator as parameter
       type will work
	  instead.

	  Feature-test macro  Value    Std		   Feature
	  __cpp_lib_flat_set 202207L (C++23) std::flat_set and	std::flat_mul-
       tiset

Example
	   This	section	is incomplete
	   Reason: no example

See also
	  flat_set	      adapts  a	 container  to provide a collection of
       unique keys, sorted
	  (C++23)	     by	keys
			     (class template)
	  multiset	     collection	of keys, sorted	by keys
			     (class template)
	  unordered_multiset collection	of keys, hashed	by keys
	  (C++11)	     (class template)

Categories:
	    * Todo without reason
	    * Todo no example

http://cppreference.com		  2024.06.10		 std::flat_multiset(3)

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

home | help