Subclause | Header | |
Requirements | ||
Sequence containers | <array>, <deque>, <forward_list>,
<inplace_vector>, | |
<list>, <vector> | ||
Associative containers | <map>, <set> | |
Unordered associative containers | <unordered_map>, <unordered_set> | |
Container adaptors | <queue>, <stack>, <flat_map>, <flat_set> | |
Views | <span>, <mdspan> |
typename X::value_type
typename X::reference
typename X::const_reference
typename X::iterator
typename X::const_iterator
typename X::difference_type
typename X::size_type
X u;
X u = X();
X u(v);
X u = v;
X u(rv);
X u = rv;
t = v;
t = rv
a.~X()
b.begin()
b.end()
b.cbegin()
b.cend()
i <=> j
c == b
c != b
t.swap(s)
swap(t, s)
c.size()
c.max_size()
c.empty()
typename X::reverse_iterator
typename X::const_reverse_iterator
a.rbegin()
a.rend()
a.crbegin()
a.crend()
a <=> b
typename X::allocator_type
c.get_allocator()
X u;
X u = X();
X u(m);
X u(t, m);
X u(rv);
X u(rv, m);
a = t
a = rv
a.swap(b)
X u(n, t);
X u(i, j);
X(from_range, rg)
X(il)
a = il
a.emplace(p, args)
a.insert(p, t)
a.insert(p, rv)
a.insert(p, n, t)
a.insert(p, i, j)
a.insert_range(p, rg)
a.insert(p, il)
a.erase(q)
a.erase(q1, q2)
a.clear()
a.assign(i, j)
a.assign_range(rg)
a.assign(il)
a.assign(n, t)
a.front()
a.back()
a.emplace_front(args)
a.emplace_back(args)
a.push_front(t)
a.push_front(rv)
a.prepend_range(rg)
a.push_back(t)
a.push_back(rv)
a.append_range(rg)
a.pop_front()
a.pop_back()
a[n]
a.at(n)
map<K, T, C1, A> | map<K, T, C2, A> |
map<K, T, C1, A> | multimap<K, T, C2, A> |
set<K, C1, A> | set<K, C2, A> |
set<K, C1, A> | multiset<K, C2, A> |
unordered_map<K, T, H1, E1, A> | unordered_map<K, T, H2, E2, A> |
unordered_map<K, T, H1, E1, A> | unordered_multimap<K, T, H2, E2, A> |
unordered_set<K, H1, E1, A> | unordered_set<K, H2, E2, A> |
unordered_set<K, H1, E1, A> | unordered_multiset<K, H2, E2, A> |
node-handle(node-handle&& nh) noexcept;
node-handle& operator=(node-handle&& nh);
~node-handle();
value_type& value() const;
key_type& key() const;
mapped_type& mapped() const;
allocator_type get_allocator() const;
explicit operator bool() const noexcept;
bool empty() const noexcept;
void swap(node-handle& nh)
noexcept(ator_traits::propagate_on_container_swap::value ||
ator_traits::is_always_equal::value);
typename X::key_type
typename X::mapped_type
typename X::value_type
typename X::key_compare
typename X::value_compare
typename X::node_type
X(c)
X u = X();
X u;
X(i, j, c)
X(i, j)
X(from_range, rg, c)
X(from_range, rg)
X(il, c)
X(il)
a = il
b.key_comp()
b.value_comp()
a_uniq.emplace(args)
a_eq.emplace(args)
a.emplace_hint(p, args)
a_uniq.insert(t)
a_eq.insert(t)
a.insert(p, t)
a.insert(i, j)
a.insert_range(rg)
a.insert(il)
a_uniq.insert(nh)
a_eq.insert(nh)
a.insert(p, nh)
a.extract(k)
a_tran.extract(kx)
a.extract(q)
a.merge(a2)
a.erase(k)
a_tran.erase(kx)
a.erase(q)
a.erase(r)
a.erase(q1, q2)
a.clear()
b.find(k)
a_tran.find(ke)
b.count(k)
a_tran.count(ke)
b.contains(k)
a_tran.contains(ke)
b.lower_bound(k)
a_tran.lower_bound(kl)
b.upper_bound(k)
a_tran.upper_bound(ku)
b.equal_range(k)
a_tran.equal_range(ke)
typename X::key_type
typename X::mapped_type
typename X::value_type
typename X::hasher
typename X::key_equal
typename X::local_iterator
typename X::const_local_iterator
typename X::node_type
X(n, hf, eq)
X(n, hf)
X(n)
X a = X();
X a;
X(i, j, n, hf, eq)
X(i, j, n, hf)
X(i, j, n)
X(i, j)
X(from_range, rg, n, hf, eq)
X(from_range, rg, n, hf)
X(from_range, rg, n)
X(from_range, rg)
X(il)
X(il, n)
X(il, n, hf)
X(il, n, hf, eq)
X(b)
a = b
a = il
b.hash_function()
b.key_eq()
a_uniq.emplace(args)
a_eq.emplace(args)
a.emplace_hint(p, args)
a_uniq.insert(t)
a_eq.insert(t)
a.insert(p, t)
a.insert(i, j)
a.insert_range(rg)
a.insert(il)
a_uniq.insert(nh)
a_eq.insert(nh)
a.insert(q, nh)
a.extract(k)
a_tran.extract(kx)
a.extract(q)
a.merge(a2)
a.erase(k)
a_tran.erase(kx)
a.erase(q)
a.erase(r)
a.erase(q1, q2)
a.clear()
b.find(k)
a_tran.find(ke)
b.count(k)
a_tran.count(ke)
b.contains(k)
a_tran.contains(ke)
b.equal_range(k)
a_tran.equal_range(ke)
b.bucket_count()
b.max_bucket_count()
b.bucket(k)
a_tran.bucket(ke)
b.bucket_size(n)
b.begin(n)
b.end(n)
b.cbegin(n)
b.cend(n)
b.load_factor()
b.max_load_factor()
a.max_load_factor(z)
a.rehash(n)
a.reserve(n)
template<class T, class... U>
array(T, U...) -> array<T, 1 + sizeof...(U)>;
constexpr size_type size() const noexcept;
constexpr T* data() noexcept;
constexpr const T* data() const noexcept;
constexpr void fill(const T& u);
constexpr void swap(array& y) noexcept(is_nothrow_swappable_v<T>);
template<class T, size_t N>
constexpr void swap(array<T, N>& x, array<T, N>& y) noexcept(noexcept(x.swap(y)));
template<class T, size_t N>
constexpr array<remove_cv_t<T>, N> to_array(T (&a)[N]);
template<class T, size_t N>
constexpr array<remove_cv_t<T>, N> to_array(T (&&a)[N]);
template<class T, size_t N>
struct tuple_size<array<T, N>> : integral_constant<size_t, N> { };
template<size_t I, class T, size_t N>
struct tuple_element<I, array<T, N>> {
using type = T;
};
template<size_t I, class T, size_t N>
constexpr T& get(array<T, N>& a) noexcept;
template<size_t I, class T, size_t N>
constexpr T&& get(array<T, N>&& a) noexcept;
template<size_t I, class T, size_t N>
constexpr const T& get(const array<T, N>& a) noexcept;
template<size_t I, class T, size_t N>
constexpr const T&& get(const array<T, N>&& a) noexcept;
explicit deque(const Allocator&);
explicit deque(size_type n, const Allocator& = Allocator());
deque(size_type n, const T& value, const Allocator& = Allocator());
template<class InputIterator>
deque(InputIterator first, InputIterator last, const Allocator& = Allocator());
template<container-compatible-range<T> R>
deque(from_range_t, R&& rg, const Allocator& = Allocator());
void resize(size_type sz);
void resize(size_type sz, const T& c);
void shrink_to_fit();
iterator insert(const_iterator position, const T& x);
iterator insert(const_iterator position, T&& x);
iterator insert(const_iterator position, size_type n, const T& x);
template<class InputIterator>
iterator insert(const_iterator position,
InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
iterator insert_range(const_iterator position, R&& rg);
iterator insert(const_iterator position, initializer_list<T>);
template<class... Args> reference emplace_front(Args&&... args);
template<class... Args> reference emplace_back(Args&&... args);
template<class... Args> iterator emplace(const_iterator position, Args&&... args);
void push_front(const T& x);
void push_front(T&& x);
template<container-compatible-range<T> R>
void prepend_range(R&& rg);
void push_back(const T& x);
void push_back(T&& x);
template<container-compatible-range<T> R>
void append_range(R&& rg);
iterator erase(const_iterator position);
iterator erase(const_iterator first, const_iterator last);
void pop_front();
void pop_back();
template<class T, class Allocator, class U = T>
typename deque<T, Allocator>::size_type
erase(deque<T, Allocator>& c, const U& value);
template<class T, class Allocator, class Predicate>
typename deque<T, Allocator>::size_type
erase_if(deque<T, Allocator>& c, Predicate pred);