FreeBSD Manual Pages

home | help
std::flat_m...lat_multiset(3) C++ Standard Libarystd::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
       optionally
	  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
       contents	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 allo-
       cator 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
       usage note
	  below.
	  9) Same as (7), equivalent to	flat_multiset(s, cont, comp);. See al-
       locator 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
       compare(comp).
	  21,22) Same as (20). See allocator usage note	below.
	  23) An initializer-list constructor. Constructs the underlying  con-
       tainer 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 con-
       tainer 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 un-
       derlying
			container
	  other	      -	another	flat_multiset to be used as source to initial-
       ize the elements
			of the underlying container with
	  alloc	       - an allocator to use for all memory allocations	of the
       underlying
			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
       underlying
			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 con-
       tainer, i.e.
	  constant or linear in	size of	cont.
	  4-6) Linear in \(\scriptsize N\)N if cont is sorted with respect  to
       compare,
	  otherwise   \(\scriptsize   \mathcal{O}(N\cdot\log{(N)})\)(Nlog(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)})\)(Nlog(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)})\)(Nlog(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)})\)(Nlog(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)
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::flat_multiset::flat_multiset&sektion=3&manpath=FreeBSD+Ports+15.1.quarterly>
home | help
Header And Logo

Peripheral Links

Site Navigation

FreeBSD Manual Pages

Header And Logo

Peripheral Links

Search

Site Navigation

FreeBSD Manual Pages
