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 op-
     tionally
	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 con-
     tents 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 usage
     note below.
	9) Same as (7), equivalent to flat_set(s, 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 container with the contents of the range
	[first,  last).  Initializes c with c(first, last) and compare with com-
     pare(comp).
	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.

	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  under-
     lying
		      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  un-
     derlying
		      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 un-
     derlying
		      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  container,
     i.e.
	constant or linear in size of cont.
	4-6) Linear in \(\scriptsize N\)N if cont is sorted with respect to com-
     pare,
	otherwise   \(\scriptsize   \mathcal{O}(N\cdot\log{(N)})\)dh(NA.log(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)})\)dh(NA.log(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)})\)dh(NA.log(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)})\)dh(NA.log(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)
home | help