[inplace.vector.overview] (original) (raw)

An inplace_vector is a contiguous container.

Its capacity is fixed and its elements are stored within the inplace_vector object itself.

An inplace_vector meets all of the requirements of a container ([container.reqmts]), of a reversible container ([container.rev.reqmts]), of a contiguous container, and of a sequence container, including most of the optional sequence container requirements ([sequence.reqmts]).

The exceptions are thepush_front,prepend_range,pop_front, andemplace_frontmember functions, which are not provided.

Descriptions are provided here only for operations on inplace_vector that are not described in one of these tables or for operations where there is additional semantic information.

For any N,inplace_vector<T, N>​::​iterator andinplace_vector<T, N>​::​const_iteratormeet the constexpr iterator requirements.

Any member function of inplace_vector<T, N> that would cause the size to exceed Nthrows an exception of type bad_alloc.

Let IV denote a specialization of inplace_vector<T, N>.

If N is zero, thenIV is trivially copyable and empty, andstd​::​is_trivially_default_constructible_v<IV> is true.

Otherwise:

namespace std { template<class T, size_t N> class inplace_vector { public: using value_type = T;using pointer = T*;using const_pointer = const T*;using reference = value_type&;using const_reference = const value_type&;using size_type = size_t;using difference_type = ptrdiff_t;using iterator = implementation-defined; using const_iterator = implementation-defined; using reverse_iterator = std::reverse_iterator<iterator>;using const_reverse_iterator = std::reverse_iterator<const_iterator>;constexpr inplace_vector() noexcept;constexpr explicit inplace_vector(size_type n); constexpr inplace_vector(size_type n, const T& value); template<class InputIterator> constexpr inplace_vector(InputIterator first, InputIterator last); template<container-compatible-range<T> R> constexpr inplace_vector(from_range_t, R&& rg); constexpr inplace_vector(const inplace_vector&);constexpr inplace_vector(inplace_vector&&) noexcept(N == 0 || is_nothrow_move_constructible_v<T>);constexpr inplace_vector(initializer_list<T> il); constexpr ~inplace_vector();constexpr inplace_vector& operator=(const inplace_vector& other);constexpr inplace_vector& operator=(inplace_vector&& other) noexcept(N == 0 || (is_nothrow_move_assignable_v<T> && is_nothrow_move_constructible_v<T>));constexpr inplace_vector& operator=(initializer_list<T>); template<class InputIterator> constexpr void assign(InputIterator first, InputIterator last); template<container-compatible-range<T> R> constexpr void assign_range(R&& rg); constexpr void assign(size_type n, const T& u); constexpr void assign(initializer_list<T> il); constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr reverse_iterator rbegin() noexcept;constexpr const_reverse_iterator rbegin() const noexcept;constexpr reverse_iterator rend() noexcept;constexpr const_reverse_iterator rend() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr const_reverse_iterator crbegin() const noexcept;constexpr const_reverse_iterator crend() const noexcept;constexpr bool empty() const noexcept;constexpr size_type size() const noexcept;static constexpr size_type max_size() noexcept;static constexpr size_type capacity() noexcept;constexpr void resize(size_type sz); constexpr void resize(size_type sz, const T& c); static constexpr void reserve(size_type n); static constexpr void shrink_to_fit() noexcept;constexpr reference operator[](size_type n);constexpr const_reference operator[](size_type n) const;constexpr reference at(size_type n); constexpr const_reference at(size_type n) const; constexpr reference front();constexpr const_reference front() const;constexpr reference back();constexpr const_reference back() const;constexpr T* data() noexcept;constexpr const T* data() const noexcept;template<class... Args> constexpr reference emplace_back(Args&&... args); constexpr reference push_back(const T& x); constexpr reference push_back(T&& x); template<container-compatible-range<T> R> constexpr void append_range(R&& rg); constexpr void pop_back();template<class... Args> constexpr pointer try_emplace_back(Args&&... args);constexpr pointer try_push_back(const T& x);constexpr pointer try_push_back(T&& x);template<container-compatible-range<T> R> constexpr ranges::borrowed_iterator_t<R> try_append_range(R&& rg);template<class... Args> constexpr reference unchecked_emplace_back(Args&&... args);constexpr reference unchecked_push_back(const T& x);constexpr reference unchecked_push_back(T&& x);template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args); 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);constexpr iterator erase(const_iterator position);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void swap(inplace_vector& x) noexcept(N == 0 || (is_nothrow_swappable_v<T> && is_nothrow_move_constructible_v<T>));constexpr void clear() noexcept;friend constexpr bool operator==(const inplace_vector& x,const inplace_vector& y);friend constexpr synth-three-way-result<T> operator<=>(const inplace_vector& x, const inplace_vector& y);friend constexpr void swap(inplace_vector& x, inplace_vector& y) noexcept(N == 0 || (is_nothrow_swappable_v<T> && is_nothrow_move_constructible_v<T>)) { x.swap(y); } };}