23 Containers library [containers]

23.3 Sequence containers [sequences]

23.3.16 Class template inplace_vector [inplace.vector]

23.3.16.5 Modifiers [inplace.vector.modifiers]

constexpr iterator insert(const_iterator position, const T& x);
constexpr iterator insert(const_iterator position, T&& x);
constexpr iterator insert(const_iterator position, size_type n, const T& x);
template<class InputIterator>
  constexpr iterator insert(const_iterator position, InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
  constexpr iterator insert_range(const_iterator position, R&& rg);
constexpr iterator insert(const_iterator position, initializer_list<T> il);

template<class... Args>
  constexpr iterator emplace(const_iterator position, Args&&... args);
template<container-compatible-range<T> R>
  constexpr void append_range(R&& rg);

Let n be the value of size() before this call for the append_range overload, and distance(begin, position) otherwise.

Complexity: Linear in the number of elements inserted plus the distance to the end of the vector.

Remarks: If an exception is thrown other than by the copy constructor, move constructor, assignment operator, or move assignment operator of T or by any InputIterator operation, there are no effects.

Otherwise, if an exception is thrown, then size() ≥ n and elements in the range begin() + [0, n) are not modified.

🔗

constexpr reference push_back(const T& x);
constexpr reference push_back(T&& x);
template<class... Args>
  constexpr reference emplace_back(Args&&... args);

Returns: back().

Throws: bad_alloc or any exception thrown by the initialization of the inserted element.

Complexity: Constant.

Remarks: If an exception is thrown, there are no effects on *this.

🔗

template<class... Args>
  constexpr optional<reference> try_emplace_back(Args&&... args);
constexpr optional<reference> try_push_back(const T& x);
constexpr optional<reference> try_push_back(T&& x);

Let vals denote a pack:

(8.1)
std::forward<Args>(args)... for the first overload,
(8.2)
x for the second overload,
(8.3)
std::move(x) for the third overload.

Preconditions: value_type is Cpp17EmplaceConstructible into inplace_vector from vals....

Effects: If size() < capacity() is true, appends an object of type T direct-non-list-initialized with vals....

Otherwise, there are no effects.

Returns: nullopt if size() == capacity() is true, otherwise optional<reference>(in_place, back()).

Throws: Nothing unless an exception is thrown by the initialization of the inserted element.

Complexity: Constant.

Remarks: If an exception is thrown, there are no effects on *this.

🔗

template<class... Args>
  constexpr reference unchecked_emplace_back(Args&&... args);

Preconditions: size() < capacity() is true.

Effects: Equivalent to: return *try_emplace_back(std::forward<Args>(args)...);

🔗

constexpr reference unchecked_push_back(const T& x);
constexpr reference unchecked_push_back(T&& x);

Preconditions: size() < capacity() is true.

Effects: Equivalent to: return *try_push_back(std::forward<decltype(x)>(x));

🔗

constexpr iterator erase(const_iterator position);
constexpr iterator erase(const_iterator first, const_iterator last);
constexpr void pop_back();

Effects: Invalidates iterators and references at or after the point of the erase.

Throws: Nothing unless an exception is thrown by the assignment operator or move assignment operator of T.

Complexity: The destructor of T is called the number of times equal to the number of the elements erased, but the assignment operator of T is called the number of times equal to the number of elements after the erased elements.

🔗

constexpr void swap(inplace_vector& x) noexcept(
  N == 0 || (is_nothrow_swappable_v<T> && is_nothrow_move_constructible_v<T>));

Preconditions: T meets the Cpp17MoveConstructible requirements.

Let M be min(size(), x.size()).

For each non-negative integer

n < M

, (*this)[n] is swappable with x[n] ([swappable.requirements]).

Effects: Exchanges the contents of *this and x.