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 container 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 compare(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 constructor.
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 constructor.
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 underlying
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 sequence 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 compare,
otherwise \(\scriptsize \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·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 container, 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)})\)𝓞(N·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 \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·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 \mathcal{O}(N\cdot\log{(N)})\)𝓞(N·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