std::flat_set::flat_set(3)

💖 NAME 💖

okay so bestie, welcome to std::flat_set::flat_set(3) from the C++ Standard Libary (yep, that spelling is right there and we are respecting it 💅). This is part 1 of 2, and the name of the game is:

std::flat_set::flat_set — std::flat_set::flat_set

---

✨ Synopsis ✨

bestie, this is the whole overload lineup. all of these are (since C++23), and yes, there are 28 of them. no cap, we're keeping every single one exactly as written:

          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 );

---

🌸 Description 🌸

okay so the whole vibe here is: construct a new container adaptor from a bunch of different data sources, and you can optionally pass a comparison function object comp and/or an allocator alloc. that's the tea 🫖✨

🎀 Overloads, one by one 🎀

• (1) — a default constructor. constructs an empty container adaptor. the body is literally : flat_set(key_compare()) { } 💅
• (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. slay, but also read that carefully 🔥
• (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. the body is : c(std::move(cont)), compare(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. the body is : c(), compare(comp) { } 💖
• (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);. the body is : c(), compare(comp); 🌈
• (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));. the body is : flat_set(comp); 🦋
• (17) — same as (16) using it as delegating constructor. the body is : flat_set( fr, std::forward<R>(rg), key_compare() ) { } 🎀
• (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). the body is : c(first, last), 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. the body is : flat_set(init.begin(), init.end(), comp) { } 🍓
• (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. the body is : flat_set(s, init.begin(), init.end(), comp) { } 🧚
• (27,28) — Save as (26). see allocator usage note below 🫶 (yes, the page says “Save as” — we are not fixing it, we are respecting the lore 💅)

🚨 Note for overloads (13-15,20-22): if [first, last) is not a valid range, the behavior is undefined. literally do not, bestie 😭

💀 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). no cap, that's the caveat 🔥

---

🦋 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
• rg — a container compatible range (that is, an input_range whose elements 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.

periodt 💅✨

💅 COMPLEXITY 💅

okay so here's the complexity tea, bestie — every group is numbered exactly like the original, no cap ✨

• 1) — Constant. literally just 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 N if cont is sorted with respect to compare, otherwise O(N·log(N)), where 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. iconic, honestly 🎀
• 13-15) — Linear in N if the input range [first, last) is sorted with respect to compare, otherwise O(N·log(N)), where N is the value of cont.size() before this call.
• 16-19) — Linear in N if the input range rg is sorted with respect to compare, otherwise O(N·log(N)), where N is the value of cont.size() before this call.
• 20-22) — Linear in size of [first, last).
• 23-25) — Linear in N if the elements of init are sorted with respect to compare, otherwise O(N·log(N)), where N is the value of cont.size() before this call.
• 26-28) — Linear in size of init.

---

🚨 EXCEPTIONS 🚨

Calls to Allocator::allocate may throw. that's it, that's the warning 🫶

---

📝 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. iykyk, standard-nerd lore 💜

---

🧪 EXAMPLE 🧪

This section is incomplete.

Reason: no example.

bestie they really said “no example” and left it at that 😭🙈

---

👀 SEE ALSO 👀

• operator= assigns values to the container adaptor (public member function)

---

🏷️ CATEGORY

• Todo no example

---

💖 source: cppreference.com · version 2024.06.10 · page std::flat_set::flat_set(3) — mwah, bye bestie! 💖