FreeBSD Manual Pages

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

NAME
       std::flat_set::flat_set - std::flat_set::flat_set

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

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

		    const Allocator& alloc );
	  flat_set( std::sorted_unique_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_set(   std::sorted_unique_t   s,	 const	container_type&	 cont,
       (8)  (since C++23)

		    const Allocator& alloc );
	  template< class Allocator >

	  flat_set(  std::sorted_unique_t  s,  const   container_type&	 cont,
       (9)  (since C++23)

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

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

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

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

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

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

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

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

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

		    const Allocator& alloc );
	  template< class InputIter >

	  flat_set( std::sorted_unique_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_set(  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_set(   std::sorted_unique_t   s,	  InputIter  first,  InputIter
       (22) (since C++23)
	  last,

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

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

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

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

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

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

	  flat_set(		      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_set(		     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
	  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.	Finally, makes elements	 unique,  i.e.	erases
       all but the first
	  element from each group of consecutive equivalent elements.
	  5)  Same  as (4), equivalent to flat_set(cont);. See allocator usage
       note below.
	  6) Same as (4), equivalent to	flat_set(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_set(s, cont);. See	allocator  us-
       age note	below.
	  9)  Same as (7), equivalent to flat_set(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
       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.

	  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
	  cont	      -	a container to be used as source to initialize the un-
       derlying
			container
	  other	       -  another  flat_set 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
       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  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
       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_set::flat_set(3)
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::flat_set::flat_set&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
