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

NAME
     std::flat_multimap::flat_multimap - std::flat_multimap::flat_multimap

Synopsis
	flat_multimap() 						     (1)
     (since C++23)
	    : flat_multimap(key_compare()) { }
	template< class  Allocator  >					     (2)
     (since C++23)
	flat_multimap( const flat_multimap&, const Allocator& alloc );
	template<  class  Allocator  >					     (3)
     (since C++23)
	flat_multimap( flat_multimap&&, const Allocator& alloc );
	flat_multimap( key_container_type key_cont, mapped_container_type
	mapped_cont,							     (4)
     (since C++23)
		       const key_compare& comp = key_compare() );
	template< class Allocator >

	flat_multimap(	const  key_container_type&  key_cont,		     (5)
     (since C++23)
		       const mapped_container_type& mapped_cont,

		       const Allocator& alloc );
	template< class Allocator >

	flat_multimap( const  key_container_type&  key_cont,		     (6)
     (since C++23)
		       const mapped_container_type& mapped_cont,

		       const key_compare& comp, const Allocator& alloc );
	flat_multimap( std::sorted_equivalent_t, key_container_type
	key_cont,
									  (7)
     (since C++23)
		       mapped_container_type mapped_cont,

		       const key_compare& comp = key_compare() );
	template< class Allocator >

	flat_multimap( std::sorted_equivalent_t, const
	key_container_type&   key_cont, 				     (8)
     (since C++23)

		       const mapped_container_type& mapped_cont, const
	Allocator& alloc );
	template< class Allocator >

	flat_multimap( std::sorted_equivalent_t, const
	key_container_type&  key_cont,					     (9)
     (since C++23)
		       const mapped_container_type& mapped_cont,

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

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

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

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

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

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

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

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

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

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

		       const Allocator& alloc );
	template< class InputIter >

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

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

	flat_multimap( 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_multimap(	std::sorted_equivalent_t  s, InputIter first,	    (22)
     (since C++23)
	InputIter last,

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

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

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

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

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

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

	flat_multimap(	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_multimap( 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 using
	user supplied 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) First, initializes c.keys with std::move(key_cont), c.values with
	std::move(mapped_cont), and compare with comp. Then sorts the underlying
     range
	[begin(), end()) with respect to value_comp().
	5) Same as (4), equivalent to flat_multimap(key_cont, mapped_cont);. See
     allocator
	usage note below.
	6) Same  as  (4),  equivalent  to  flat_multimap(key_cont,  mapped_cont,
     comp);. See
	allocator usage note below.
	7) Initializes c.keys with std::move(key_cont), c.values with
	std::move(mapped_cont), and compare with comp.
	8)  Same as (7), equivalent to flat_multimap(s, key_cont, mapped_cont);.
     See
	allocator usage note below.
	9) Same as (7), equivalent to  flat_multimap(s,  key_cont,  mapped_cont,
     comp);. See
	allocator 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 containers with the contents of the range
	[first, last) as if by insert(first, last).
	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
	key_cont     - a container to be used as source to initialize the under-
     lying keys
		      container
	mapped_cont - a container to be used as source to initialize the  under-
     lying values
		      container
	other	     -	another flat_multimap to be used as source to initialize
     the elements
		      of the underlying containers with
	alloc	    - an allocator to use for all memory allocations of the  un-
     derlying
		      containers
	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
		      containers 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 containers
	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 value_comp()

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
     value_comp(),
	otherwise   \(\scriptsize   \mathcal{O}(N\cdot\log{(N)})\)dh(NA.log(N)),
     where
	\(\scriptsize N\)N is the value of key_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 value_comp(), otherwise \(\scriptsize
	\mathcal{O}(N\cdot\log{(N)})\)dh(NA.log(N)), where \(\scriptsize N\)N is
     the value of
	key_cont.size() before this call.
	16-19) Linear in \(\scriptsize N\)N if the input range rg is sorted with
     respect to
	value_comp(),		otherwise	   \(\scriptsize	  \math-
     cal{O}(N\cdot\log{(N)})\)dh(NA.log(N)),
	where \(\scriptsize N\)N is the value  of  key_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	 value_comp(),	     otherwise	     \(\scriptsize	  \math-
     cal{O}(N\cdot\log{(N)})\)dh(NA.log(N)),
	where  \(\scriptsize  N\)N  is	the value of key_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)), 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_multimap(3)
home | help