23 Containers library [containers]

23.6 Container adaptors [container.adaptors]

23.6.11 Class template flat_set [flat.set]

23.6.11.5 Modifiers [flat.set.modifiers]

template<class K> constexpr pair<iterator, bool> insert(K&& x);
template<class K> constexpr iterator insert(const_iterator hint, K&& x);

Constraints: The qualified-id Compare::is_transparent is valid and denotes a type.

is_constructible_v<value_type, K> is true.

Preconditions: The conversion from x into value_type constructs an object u, for which find(x) == find(u) is true.

Effects: If the set already contains an element equivalent to x, *this and x are unchanged.

Otherwise, inserts a new element as if by emplace(std::forward<K>(x)).

Returns: In the first overload, the bool component of the returned pair is true if and only if the insertion took place.

The returned iterator points to the element whose key is equivalent to x.

🔗

template<class InputIterator>
  constexpr void insert(InputIterator first, InputIterator last);

Effects: Adds elements to c as if by: c.insert(c.end(), first, last);

Then, sorts the range of newly inserted elements with respect to compare; merges the resulting sorted range and the sorted range of pre-existing elements into a single sorted range; and finally erases all but the first element from each group of consecutive equivalent elements.

Complexity: N +

M log M

, where N is size() before the operation and M is distance(first, last).

Remarks: Since this operation performs an in-place merge, it may allocate memory.

🔗

template<class InputIterator>
  constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);

Effects: Equivalent to insert(first, last).

Complexity: Linear.

🔗

template<container-compatible-range<value_type> R>
  constexpr void insert_range(R&& rg);

Effects: Adds elements to c as if by: ranges::for_each(rg, [&](auto&& e) { c.insert(c.end(), std::forward<decltype(e)>(e)); });

Complexity: N +

M log M

, where N is size() before the operation and M is ranges::distance(rg).

Remarks: Since this operation performs an in-place merge, it may allocate memory.

🔗

template<container-compatible-range<value_type> R>
  constexpr void insert_range(sorted_unique_t, R&& rg);

Effects: Equivalent to insert_range(rg).

Complexity: Linear in N, where N is size() after the operation.

🔗

constexpr void swap(flat_set& y)
  noexcept(is_nothrow_swappable_v<container_type> &&
           is_nothrow_swappable_v<key_compare>);

Effects: Equivalent to: ranges::swap(compare, y.compare); ranges::swap(c, y.c);

🔗

constexpr container_type extract() &&;

Postconditions: *this is emptied, even if the function exits via an exception.

Returns: std::move(c).

🔗

constexpr void replace(container_type&& cont);

Preconditions: The elements of cont are sorted with respect to compare, and cont contains no equal elements.

Effects: Equivalent to: c = std::move(cont);