标准库标头 <inplace_vector> (C++26)
来自cppreference.com
此标头是容器库的一部分。
包含 | |
(C++20) |
三路比较运算符支持 |
(C++11) |
std::initializer_list 类模板 |
类 | |
(C++26) |
可动态调整大小的固定容量原位连续数组 (类模板) |
函数 | |
| 擦除所有满足特定判别标准的元素 (函数模板) | |
概要
// 大多数独立
#include <compare>
#include <initializer_list>
namespace std {
// 类模板 inplace_vector
template<class T, size_t N> class inplace_vector; // 部分独立
// 擦除
template<class T, size_t N, class U = T>
constexpr typename inplace_vector<T, N>::size_type erase(inplace_vector<T, N>& c,
const U& value);
template<class T, size_t N, class Predicate>
constexpr typename inplace_vector<T, N>::size_type erase_if(inplace_vector<T, N>& c,
Predicate pred);
}
类模板 std::inplace_vector
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 = /* 由实现定义 */;
using const_iterator = /* 由实现定义 */;
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 InputIter>
constexpr inplace_vector(InputIter first, InputIter 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 InputIter>
constexpr void assign(InputIter first, InputIter 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 optional<reference> try_emplace_back(Args&&... args);
constexpr optional<reference> try_push_back(const T& x);
constexpr optional<reference> try_push_back(T&& x);
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 InputIter>
constexpr iterator insert(const_iterator position, // 独立环境删除
InputIter first,
InputIter 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 auto operator<=>(const inplace_vector& x, const inplace_vector& y)
requires requires(const T t) { /*synth-three-way*/(t, t); }
{
return lexicographical_compare_three_way(x.begin(), x.end(), y.begin(), y.end(),
/*synth-three-way*/);
}
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);
}
};
}