home | help 
std::flat_m...lat_multiset(3)  C++ Standard Libary std::flat_m...lat_multiset(3)

NAME
     std::flat_multiset::flat_multiset - std::flat_multiset::flat_multiset

Synopsis
	flat_multiset() 						     (1)
     (since C++23)
	    : flat_multiset(key_compare()) { }
	template< class Allocator >
	flat_multiset( const flat_multiset& other, const  Allocator&  alloc  (2)
     (since C++23)
	);
	template<  class  Allocator  >					     (3)
     (since C++23)
	flat_multiset( flat_multiset&& other, const Allocator& alloc );
	explicit flat_multiset( container_type cont,
				const key_compare& comp  =  key_compare()    (4)
     (since C++23)
	);
	template< class Allocator >
	flat_multiset(	const  container_type&	cont, const Allocator& alloc (5)
     (since C++23)
	);
	template< class Allocator >

	flat_multiset( const container_type& cont,  const  key_compare&      (6)
     (since C++23)
	comp,

		       const Allocator& alloc );
	flat_multiset( std::sorted_equivalent_t s, container_type cont,

		       const  key_compare&  comp  = key_compare() )	     (7)
     (since C++23)

	    : c(std::move(cont)), compare(comp) { }
	template< class Allocator >

	flat_multiset( std::sorted_equivalent_t s,  const  container_type&   (8)
     (since C++23)
	cont,

		       const Allocator& alloc );
	template< class Allocator >

	flat_multiset(	std::sorted_equivalent_t  s,  const container_type&  (9)
     (since C++23)
	cont,

		       const key_compare& comp, const Allocator& alloc );
	explicit flat_multiset( const key_compare& comp  )		    (10)
     (since C++23)
	    : c(), compare(comp) { }
	template<  class  Allocator >					    (11)
     (since C++23)
	flat_multiset( const key_compare& comp, const Allocator& alloc );
	template< class Allocator  >					    (12)
     (since C++23)
	explicit flat_multiset( const Allocator& alloc );
	template< class InputIter >

	flat_multiset(	InputIter  first, InputIter last,		    (13)
     (since C++23)
		       const key_compare& comp = key_compare() )

	    : c(), compare(comp);
	template< class InputIter, class Allocator >

	flat_multiset( InputIter first, InputIter  last,		    (14)
     (since C++23)

		       const key_compare& comp, const Allocator& alloc );
	template< class InputIter, class Allocator >
	flat_multiset(	InputIter  first, InputIter last, const Allocator&  (15)
     (since C++23)
	alloc );
	template< container-compatible-range<value_type> R >

	flat_multiset( std::from_range_t, R&& rg, const key_compare&  comp  (16)
     (since C++23)
	)

	    : flat_multiset(comp);
	template< container-compatible-range<value_type> R >

	flat_multiset(	std::from_range_t  fr, R&& rg ) 		    (17)
     (since C++23)

	    : flat_multiset( fr, std::forward<R>(rg), key_compare() ) { }
	template< container-compatible-range<value_type> R, class
	Allocator  >							    (18)
     (since C++23)
	flat_multiset( std::from_range_t, R&& rg, const Allocator& alloc
	);
	template< container-compatible-range<value_type> R, class
	Allocator >

	flat_multiset(	std::from_range_t,  R&& rg, const key_compare&	    (19)
     (since C++23)
	comp,

		       const Allocator& alloc );
	template< class InputIter >

	flat_multiset( std::sorted_equivalent_t s, InputIter first,
	InputIter  last,						    (20)
     (since C++23)
		       const key_compare& comp = key_compare() )

	    : c(first, last), compare(comp) { }
	template< class InputIter, class Allocator >

	flat_multiset(	std::sorted_equivalent_t  s, InputIter first,	    (21)
     (since C++23)
	InputIter last,

		       const key_compare& comp, const Allocator& alloc );
	template< class InputIter, class Allocator >

	flat_multiset( std::sorted_equivalent_t s, InputIter  first,	    (22)
     (since C++23)
	InputIter last,

		       const Allocator& alloc );
	flat_multiset( std::initializer_list<value_type> init,

		       const  key_compare&  comp = key_compare() )	    (23)
     (since C++23)

	    : flat_multiset(init.begin(), init.end(), comp) { }
	template< class Allocator >

	flat_multiset( std::initializer_list<value_type> init,	const	    (24)
     (since C++23)
	key_compare& comp,

		       const Allocator& alloc );
	template< class Allocator >
	flat_multiset(	std::initializer_list<value_type>  init, const	    (25)
     (since C++23)
	Allocator& alloc );
	flat_multiset( std::sorted_equivalent_t s,
	std::initializer_list<value_type> init,
									  (26)
     (since C++23)
		       const key_compare& comp = key_compare() )

	    : flat_multiset(s, init.begin(), init.end(), comp) { }
	template< class Allocator >

	flat_multiset( std::sorted_equivalent_t  s,			    (27)
     (since C++23)
	std::initializer_list<value_type> init,

		       const key_compare& comp, const Allocator& alloc );
	template< class Allocator >

	flat_multiset(	std::sorted_equivalent_t  s,			    (28)
     (since C++23)
	std::initializer_list<value_type> init,

		       const Allocator& alloc );

	Constructs new container adaptor from a variety of data sources and  op-
     tionally
	provided comparison function object comp and/or allocator alloc.

	1) A default constructor. Constructs an empty container adaptor.
	2)  A  copy  constructor.  Constructs c with the copy of the contents of
     other.c and
	compare with other.compare. See allocator usage note below.
	3) A move constructor. Constructs the container adaptor  with  the  con-
     tents of other
	using move semantics. See allocator usage note below.
	4)  Constructs	the  underlying  container with the contents of the con-
     tainer cont.
	First, initializes c with std::move(cont) and compare  with  comp.  Then
     sorts the c
	with respect to comp.
	5)  Same as (4), equivalent to flat_multiset(cont);. See allocator usage
     note below.
	6) Same as (4), equivalent to flat_multiset(cont, comp);. See  allocator
     usage note
	below.
	7)  Constructs	the  underlying container with the contents of the other
     container
	cont. Initializes c with std::move(cont) and compare with comp.
	8) Same as (7), equivalent to flat_multiset(s, cont);. See allocator us-
     age note
	below.
	9) Same as (7), equivalent to flat_multiset(s, cont, comp);. See alloca-
     tor usage
	note below.
	10) Constructs an empty container adaptor.
	11,12) Constructs an empty container adaptor. See allocator  usage  note
     below.
	13)  Constructs  the  container  adaptor  with the contents of the range
     [first, last),
	equivalent to insert(first, last);.
	14,15) Same as (13). See allocator usage note below.
	16) Constructs the container adaptor with the contents of the range  rg.
     First, uses
	(10)  as delegating constructor. Then initializes c with the contents of
     rg as if by
	insert_range(std::forward<R>(rg));.
	17) Same as (16) using it as delegating constructor.
	18,19) Same as (16). See allocator usage note below.
	20) Constructs the underlying container with the contents of the range
	[first, last). Initializes c with c(first, last) and compare  with  com-
     pare(comp).
	21,22) Same as (20). See allocator usage note below.
	23) An initializer-list constructor. Constructs the underlying container
     with the
	contents  of  the  initializer	list init, using (13) as delegating con-
     structor.
	24,25) Same as (23). See allocator usage note below.
	26) An initializer-list constructor. Constructs the underlying container
     with the
	contents of the initializer list init, using  (20)  as	delegating  con-
     structor.
	27,28) Save as (26). See allocator usage note below.

	Note for overloads (13-15,20-22): If [first, last) is not a valid range,
     the
	behavior is undefined.

Parameters
	cont	     - a container to be used as source to initialize the under-
     lying
		      container
	other	    - another flat_multiset to be used as source  to  initialize
     the elements
		      of the underlying container with
	alloc	     - an allocator to use for all memory allocations of the un-
     derlying
		      container
	comp	    - a function object to be used for all comparisons of keys
	first, last - a range to copy the elements from
	init	    - an initializer list to initialize the elements of the  un-
     derlying
		      container with
		      a  container  compatible	range  (that  is, an input_range
     whose elements
	rg	    - are convertible to value_type) to be  used  as  source  to
     initialize the
		      underlying container
	fr	     -	a  disambiguation  tag that indicates that the contained
     member should
		      be range constructed
	s	    - a disambiguation tag that indicates  that  the  input  se-
     quence is sorted
		      with respect to compare

Type requirements
	-
	InputIt must meet the requirements of LegacyInputIterator.
	-
	Compare must meet the requirements of Compare.
	-
	Allocator must meet the requirements of Allocator.

Complexity
	1) Constant.
	2) Linear in size of other.
	3)  Same as the corresponding move-constructor of the wrapped container,
     i.e.
	constant or linear in size of cont.
	4-6) Linear in \(\scriptsize N\)N if cont is sorted with respect to com-
     pare,
	otherwise   \(\scriptsize   \mathcal{O}(N\cdot\log{(N)})\)dh(NA.log(N)),
     where
	\(\scriptsize N\)N is the value of cont.size() before this call.
	7-9)  Same  as	the  corresponding  move-constructor of the wrapped con-
     tainer, i.e.
	constant or linear in size of cont.
	10-12) Constant.
	13-15) Linear in \(\scriptsize N\)N if the input range [first, last)  is
     sorted with
	respect to compare, otherwise \(\scriptsize
	\mathcal{O}(N\cdot\log{(N)})\)dh(NA.log(N)), where \(\scriptsize N\)N is
     the value of
	cont.size() before this call.
	16-19) Linear in \(\scriptsize N\)N if the input range rg is sorted with
     respect to
	compare,	    otherwise		 \(\scriptsize		  \math-
     cal{O}(N\cdot\log{(N)})\)dh(NA.log(N)), where
	\(\scriptsize N\)N is the value of cont.size() before this call.
	20-22) Linear in size of [first, last).
	23-25) Linear in \(\scriptsize N\)N if the elements of init  are  sorted
     with respect
	to	   compare,	    otherwise	     \(\scriptsize	  \math-
     cal{O}(N\cdot\log{(N)})\)dh(NA.log(N)), where
	\(\scriptsize N\)N is the value of cont.size() before this call.
	26-28) Linear in size of init.

Exceptions
	Calls to Allocator::allocate may throw.

Notes
	After container  move  construction  (overload	(3,16-19)),  references,
     pointers, and
	iterators (other than the end iterator) to other remain valid, but refer
     to elements
	that are now in *this. The current standard makes this guarantee via the
     blanket
	statement in [container.reqmts]/67, and a more direct guarantee is under
	consideration via LWG issue 2321.

Example
	 This section is incomplete
	 Reason: no example

See also
	operator= assigns values to the container adaptor
		  (public member function)

Category:
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::flat_m...lat_multiset(3)
home | help