FreeBSD Manual Pages

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

NAME
       std::flat_map::flat_map - std::flat_map::flat_map

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

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

		    const Allocator& alloc );
	  template< class Allocator >

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

		    const key_compare& comp, const Allocator& alloc );
	  flat_map( std::sorted_unique_t, key_container_type key_cont,

		    mapped_container_type			  mapped_cont,
       (7)  (since C++23)

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

	  flat_map( std::sorted_unique_t, const	key_container_type&
	  key_cont,
       (8)  (since C++23)

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

	  flat_map( std::sorted_unique_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_map(      const	 key_compare&	   comp	     )
       (10) (since C++23)
	      :	c(), compare(comp) { }
	  template<		  class		      Allocator		     >
       (11) (since C++23)
	  flat_map( const key_compare& comp, const Allocator& alloc );
	  template<		 class		     Allocator		     >
       (12) (since C++23)
	  explicit flat_map( const Allocator& alloc );
	  template< class InputIter >

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

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

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

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

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

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

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

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

		    const Allocator& alloc );
	  template< class InputIter >

	  flat_map( std::sorted_unique_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_map(   std::sorted_unique_t   s,	  InputIter  first,  InputIter
       (21) (since C++23)
	  last,

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

	  flat_map(  std::sorted_unique_t  s,	InputIter   first,   InputIter
       (22) (since C++23)
	  last,

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

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

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

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

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

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

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

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

	  flat_map(		      std::sorted_unique_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(). Finally, erases the
       duplicate
	  elements as if by:
	  auto zv = views::zip(c.keys, c.values);
	  auto it = ranges::unique(zv, key_equiv(compare)).begin();
	  auto dist = distance(zv.begin(), it);
	  c.keys.erase(c.keys.begin() +	dist, c.keys.end());
	  c.values.erase(c.values.begin() + dist, c.values.end());.
	  5) Same as (4), equivalent to	flat_map(key_cont, mapped_cont);.  See
       allocator usage
	  note below.
	  6)  Same  as	(4),  equivalent  to  flat_map(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_map(s,  key_cont,	mapped_cont);.
       See allocator
	  usage	note below.
	  9)  Same  as	(7),  equivalent to flat_map(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.

	  Note	for  overloads	(4-6,13-19,23-25): If multiple elements	in the
       range have keys
	  that compare equivalent, it is unspecified which element is inserted
       (pending
	  LWG2844).

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_map 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
       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() and all its elements are
       unique

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_map::flat_map(3)
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::flat_map::flat_map&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
