FreeBSD Manual Pages

home | help
std::flat_m...lat_multimap(3) C++ Standard Libarystd::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
       optionally using
	  user supplied	comparison function object comp	and/or	allocator  al-
       loc.

	  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) First, initializes	c.keys with std::move(key_cont), c.values with
	  std::move(mapped_cont), and compare with comp. Then sorts the	under-
       lying 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 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
	  key_cont    -	a container to be used as source to initialize the un-
       derlying	keys
			container
	  mapped_cont -	a container to be used as source to initialize the un-
       derlying	values
			container
	  other	      -	another	flat_multimap to be used as source to initial-
       ize the elements
			of the underlying containers with
	  alloc	      -	an allocator to	use for	all memory allocations of  the
       underlying
			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
       underlying
			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  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
       value_comp(),
	  otherwise   \(\scriptsize   \mathcal{O}(N\cdot\log{(N)})\)(Nlog(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)})\)(Nlog(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)})\)(Nlog(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)})\)(Nlog(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,	point-
       ers, 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)
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::flat_multimap::flat_multimap&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
