Subclause | Header | ||
Requirements | |||
Sequence containers | <array>, <deque>, <forward_list>,
<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;
[[nodiscard]] 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)
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>
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);
explicit forward_list(const Allocator&);
explicit forward_list(size_type n, const Allocator& = Allocator());
forward_list(size_type n, const T& value, const Allocator& = Allocator());
template<class InputIterator>
forward_list(InputIterator first, InputIterator last, const Allocator& = Allocator());
template<container-compatible-range<T> R>
forward_list(from_range_t, R&& rg, const Allocator& = Allocator());
iterator before_begin() noexcept;
const_iterator before_begin() const noexcept;
const_iterator cbefore_begin() const noexcept;
reference front();
const_reference front() const;
template<class... Args> reference emplace_front(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 pop_front();
iterator insert_after(const_iterator position, const T& x);
iterator insert_after(const_iterator position, T&& x);
iterator insert_after(const_iterator position, size_type n, const T& x);
template<class InputIterator>
iterator insert_after(const_iterator position, InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
iterator insert_range_after(const_iterator position, R&& rg);
iterator insert_after(const_iterator position, initializer_list<T> il);
template<class... Args>
iterator emplace_after(const_iterator position, Args&&... args);
iterator erase_after(const_iterator position);
iterator erase_after(const_iterator position, const_iterator last);
void resize(size_type sz);
void resize(size_type sz, const value_type& c);
void clear() noexcept;
void splice_after(const_iterator position, forward_list& x);
void splice_after(const_iterator position, forward_list&& x);
void splice_after(const_iterator position, forward_list& x, const_iterator i);
void splice_after(const_iterator position, forward_list&& x, const_iterator i);
void splice_after(const_iterator position, forward_list& x,
const_iterator first, const_iterator last);
void splice_after(const_iterator position, forward_list&& x,
const_iterator first, const_iterator last);
size_type remove(const T& value);
template<class Predicate> size_type remove_if(Predicate pred);
size_type unique();
template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
void merge(forward_list& x);
void merge(forward_list&& x);
template<class Compare> void merge(forward_list& x, Compare comp);
template<class Compare> void merge(forward_list&& x, Compare comp);
void sort();
template<class Compare> void sort(Compare comp);
void reverse() noexcept;
template<class T, class Allocator, class U>
typename forward_list<T, Allocator>::size_type
erase(forward_list<T, Allocator>& c, const U& value);
template<class T, class Allocator, class Predicate>
typename forward_list<T, Allocator>::size_type
erase_if(forward_list<T, Allocator>& c, Predicate pred);
explicit list(const Allocator&);
explicit list(size_type n, const Allocator& = Allocator());
list(size_type n, const T& value, const Allocator& = Allocator());
template<class InputIterator>
list(InputIterator first, InputIterator last, const Allocator& = Allocator());
template<container-compatible-range<T> R>
list(from_range_t, R&& rg, const Allocator& = Allocator());
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();
void clear() noexcept;
void splice(const_iterator position, list& x);
void splice(const_iterator position, list&& x);
void splice(const_iterator position, list& x, const_iterator i);
void splice(const_iterator position, list&& x, const_iterator i);
void splice(const_iterator position, list& x, const_iterator first,
const_iterator last);
void splice(const_iterator position, list&& x, const_iterator first,
const_iterator last);
size_type remove(const T& value);
template<class Predicate> size_type remove_if(Predicate pred);
size_type unique();
template<class BinaryPredicate> size_type unique(BinaryPredicate binary_pred);
void merge(list& x);
void merge(list&& x);
template<class Compare> void merge(list& x, Compare comp);
template<class Compare> void merge(list&& x, Compare comp);
void reverse() noexcept;
void sort();
template<class Compare> void sort(Compare comp);
template<class T, class Allocator, class U>
typename list<T, Allocator>::size_type
erase(list<T, Allocator>& c, const U& value);
template<class T, class Allocator, class Predicate>
typename list<T, Allocator>::size_type
erase_if(list<T, Allocator>& c, Predicate pred);
constexpr explicit vector(const Allocator&) noexcept;
constexpr explicit vector(size_type n, const Allocator& = Allocator());
constexpr vector(size_type n, const T& value,
const Allocator& = Allocator());
template<class InputIterator>
constexpr vector(InputIterator first, InputIterator last,
const Allocator& = Allocator());
template<container-compatible-range<T> R>
constexpr vector(from_range_t, R&& rg, const Allocator& = Allocator());
constexpr size_type capacity() const noexcept;
constexpr void reserve(size_type n);
constexpr void shrink_to_fit();
constexpr void swap(vector& x)
noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
allocator_traits<Allocator>::is_always_equal::value);
constexpr void resize(size_type sz);
constexpr void resize(size_type sz, const T& c);
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>);
template<class... Args> constexpr reference emplace_back(Args&&... args);
template<class... Args> constexpr iterator emplace(const_iterator position, Args&&... args);
constexpr void push_back(const T& x);
constexpr void push_back(T&& x);
template<container-compatible-range<T> R>
constexpr void append_range(R&& rg);
constexpr iterator erase(const_iterator position);
constexpr iterator erase(const_iterator first, const_iterator last);
constexpr void pop_back();
template<class T, class Allocator, class U>
constexpr typename vector<T, Allocator>::size_type
erase(vector<T, Allocator>& c, const U& value);
template<class T, class Allocator, class Predicate>
constexpr typename vector<T, Allocator>::size_type
erase_if(vector<T, Allocator>& c, Predicate pred);
constexpr void flip() noexcept;
static constexpr void swap(reference x, reference y) noexcept;
template<class Allocator> struct hash<vector<bool, Allocator>>;
template<class T>
constexpr bool is-vector-bool-reference = see below;
template<class ParseContext>
constexpr typename ParseContext::iterator
parse(ParseContext& ctx);
template<class FormatContext>
typename FormatContext::iterator
format(const T& ref, FormatContext& ctx) const;
explicit map(const Compare& comp, const Allocator& = Allocator());
template<class InputIterator>
map(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator());
template<container-compatible-range<value_type> R>
map(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
mapped_type& operator[](const key_type& x);
mapped_type& operator[](key_type&& x);
mapped_type& at(const key_type& x);
const mapped_type& at(const key_type& x) const;
template<class P>
pair<iterator, bool> insert(P&& x);
template<class P>
iterator insert(const_iterator position, P&& x);
template<class... Args>
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
template<class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
template<class M>
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
template<class M>
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
template<class Key, class T, class Compare, class Allocator, class Predicate>
typename map<Key, T, Compare, Allocator>::size_type
erase_if(map<Key, T, Compare, Allocator>& c, Predicate pred);
explicit multimap(const Compare& comp, const Allocator& = Allocator());
template<class InputIterator>
multimap(InputIterator first, InputIterator last,
const Compare& comp = Compare(),
const Allocator& = Allocator());
template<container-compatible-range<value_type> R>
multimap(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
template<class P> iterator insert(P&& x);
template<class P> iterator insert(const_iterator position, P&& x);
template<class Key, class T, class Compare, class Allocator, class Predicate>
typename multimap<Key, T, Compare, Allocator>::size_type
erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred);
explicit set(const Compare& comp, const Allocator& = Allocator());
template<class InputIterator>
set(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator());
template<container-compatible-range<value_type> R>
set(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
template<class Key, class Compare, class Allocator, class Predicate>
typename set<Key, Compare, Allocator>::size_type
erase_if(set<Key, Compare, Allocator>& c, Predicate pred);
explicit multiset(const Compare& comp, const Allocator& = Allocator());
template<class InputIterator>
multiset(InputIterator first, InputIterator last,
const Compare& comp = Compare(), const Allocator& = Allocator());
template<container-compatible-range<value_type> R>
multiset(from_range_t, R&& rg, const Compare& comp = Compare(), const Allocator& = Allocator());
template<class Key, class Compare, class Allocator, class Predicate>
typename multiset<Key, Compare, Allocator>::size_type
erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);
unordered_map() : unordered_map(size_type(see below)) { }
explicit unordered_map(size_type n,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_map(InputIterator f, InputIterator l,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<container-compatible-range<value_type> R>
unordered_map(from_range_t, R&& rg,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
unordered_map(initializer_list<value_type> il,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
mapped_type& operator[](const key_type& k);
mapped_type& operator[](key_type&& k);
mapped_type& at(const key_type& k);
const mapped_type& at(const key_type& k) const;
template<class P>
pair<iterator, bool> insert(P&& obj);
template<class P>
iterator insert(const_iterator hint, P&& obj);
template<class... Args>
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
template<class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
template<class M>
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
template<class M>
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
template<class K, class T, class H, class P, class A, class Predicate>
typename unordered_map<K, T, H, P, A>::size_type
erase_if(unordered_map<K, T, H, P, A>& c, Predicate pred);
unordered_multimap() : unordered_multimap(size_type(see below)) { }
explicit unordered_multimap(size_type n,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_multimap(InputIterator f, InputIterator l,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<container-compatible-range<value_type> R>
unordered_multimap(from_range_t, R&& rg,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
unordered_multimap(initializer_list<value_type> il,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class P>
iterator insert(P&& obj);
template<class P>
iterator insert(const_iterator hint, P&& obj);
template<class K, class T, class H, class P, class A, class Predicate>
typename unordered_multimap<K, T, H, P, A>::size_type
erase_if(unordered_multimap<K, T, H, P, A>& c, Predicate pred);
unordered_set() : unordered_set(size_type(see below)) { }
explicit unordered_set(size_type n,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_set(InputIterator f, InputIterator l,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<container-compatible-range<value_type> R>
unordered_multiset(from_range_t, R&& rg,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
unordered_set(initializer_list<value_type> il,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class K, class H, class P, class A, class Predicate>
typename unordered_set<K, H, P, A>::size_type
erase_if(unordered_set<K, H, P, A>& c, Predicate pred);
unordered_multiset() : unordered_multiset(size_type(see below)) { }
explicit unordered_multiset(size_type n,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class InputIterator>
unordered_multiset(InputIterator f, InputIterator l,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<container-compatible-range<value_type> R>
unordered_multiset(from_range_t, R&& rg,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
unordered_multiset(initializer_list<value_type> il,
size_type n = see below,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type());
template<class K, class H, class P, class A, class Predicate>
typename unordered_multiset<K, H, P, A>::size_type
erase_if(unordered_multiset<K, H, P, A>& c, Predicate pred);
explicit queue(const Container& cont);
explicit queue(Container&& cont);
template<class InputIterator>
queue(InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
queue(from_range_t, R&& rg);
template<class Alloc> explicit queue(const Alloc& a);
template<class Alloc> queue(const container_type& cont, const Alloc& a);
template<class Alloc> queue(container_type&& cont, const Alloc& a);
template<class Alloc> queue(const queue& q, const Alloc& a);
template<class Alloc> queue(queue&& q, const Alloc& a);
template<class InputIterator, class Alloc>
queue(InputIterator first, InputIterator last, const Alloc& alloc);
template<container-compatible-range<T> R, class Alloc>
queue(from_range_t, R&& rg, const Alloc& a);
template<container-compatible-range<T> R>
void push_range(R&& rg);
template<class T, class Container>
bool operator==(const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator!=(const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator< (const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator> (const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator<=(const queue<T, Container>& x, const queue<T, Container>& y);
template<class T, class Container>
bool operator>=(const queue<T, Container>& x,
const queue<T, Container>& y);
template<class T, three_way_comparable Container>
compare_three_way_result_t<Container>
operator<=>(const queue<T, Container>& x, const queue<T, Container>& y);
priority_queue(const Compare& x, const Container& y);
priority_queue(const Compare& x, Container&& y);
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare());
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Compare& x, const Container& y);
template<class InputIterator>
priority_queue(InputIterator first, InputIterator last, const Compare& x, Container&& y);
template<container-compatible-range<T> R>
priority_queue(from_range_t, R&& rg, const Compare& x = Compare());
template<class Alloc> explicit priority_queue(const Alloc& a);
template<class Alloc> priority_queue(const Compare& compare, const Alloc& a);
template<class Alloc>
priority_queue(const Compare& compare, const Container& cont, const Alloc& a);
template<class Alloc>
priority_queue(const Compare& compare, Container&& cont, const Alloc& a);
template<class Alloc> priority_queue(const priority_queue& q, const Alloc& a);
template<class Alloc> priority_queue(priority_queue&& q, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Compare& compare, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Compare& compare,
const Container& cont, const Alloc& a);
template<class InputIterator, class Alloc>
priority_queue(InputIterator first, InputIterator last, const Compare& compare, Container&& cont,
const Alloc& a);
template<container-compatible-range<T> R, class Alloc>
priority_queue(from_range_t, R&& rg, const Compare& compare, const Alloc& a);
template<container-compatible-range<T> R, class Alloc>
priority_queue(from_range_t, R&& rg, const Alloc& a);
void push(const value_type& x);
void push(value_type&& x);
template<container-compatible-range<T> R>
void push_range(R&& rg);
template<class... Args> void emplace(Args&&... args);
void pop();
template<class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& x,
priority_queue<T, Container, Compare>& y) noexcept(noexcept(x.swap(y)));
explicit stack(const Container& cont);
explicit stack(Container&& cont);
template<class InputIterator>
stack(InputIterator first, InputIterator last);
template<container-compatible-range<T> R>
stack(from_range_t, R&& rg);
template<class Alloc> explicit stack(const Alloc& a);
template<class Alloc> stack(const container_type& cont, const Alloc& a);
template<class Alloc> stack(container_type&& cont, const Alloc& a);
template<class Alloc> stack(const stack& s, const Alloc& a);
template<class Alloc> stack(stack&& s, const Alloc& a);
template<class InputIterator, class Alloc>
stack(InputIterator first, InputIterator last, const Alloc& alloc);
template<container-compatible-range<T> R, class Alloc>
stack(from_range_t, R&& rg, const Alloc& a);
template<container-compatible-range<T> R>
void push_range(R&& rg);
template<class T, class Container>
bool operator==(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator!=(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator< (const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator> (const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, class Container>
bool operator>=(const stack<T, Container>& x, const stack<T, Container>& y);
template<class T, three_way_comparable Container>
compare_three_way_result_t<Container>
operator<=>(const stack<T, Container>& x, const stack<T, Container>& y);
flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const Allocator& a);
template<class Allocator>
flat_map(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const key_compare& comp, const Allocator& a);
flat_map(sorted_unique_t, key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_map(sorted_unique_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const Allocator& a);
template<class Allocator>
flat_map(sorted_unique_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const key_compare& comp,
const Allocator& a);
template<class Allocator>
flat_map(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_map(const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_map(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_map(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(sorted_unique_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_map(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
template<class Allocator>
flat_map(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_map(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_map(sorted_unique_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_map(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
size_type size() const noexcept;
size_type max_size() const noexcept;
mapped_type& operator[](const key_type& x);
mapped_type& operator[](key_type&& x);
template<class K> mapped_type& operator[](K&& x);
mapped_type& at(const key_type& x);
const mapped_type& at(const key_type& x) const;
template<class K> mapped_type& at(const K& x);
template<class K> const mapped_type& at(const K& x) const;
template<class... Args> pair<iterator, bool> emplace(Args&&... args);
template<class P> pair<iterator, bool> insert(P&& x);
template<class P> iterator insert(const_iterator position, P&& x);
template<class InputIterator>
void insert(InputIterator first, InputIterator last);
template<class InputIterator>
void insert(sorted_unique_t, InputIterator first, InputIterator last);
template<container-compatible-range<value_type> R>
void insert_range(R&& rg);
template<class... Args>
pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
template<class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
template<class... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
template<class K, class... Args>
pair<iterator, bool> try_emplace(K&& k, Args&&... args);
template<class K, class... Args>
iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
template<class M>
pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
template<class M>
pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
template<class M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
template<class K, class M>
pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
template<class K, class M>
iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
void swap(flat_map& y) noexcept;
containers extract() &&;
void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
class Predicate>
typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const Allocator& a);
template<class Allocator>
flat_multimap(const key_container_type& key_cont, const mapped_container_type& mapped_cont,
const key_compare& comp, const Allocator& a);
flat_multimap(sorted_equivalent_t, key_container_type key_cont, mapped_container_type mapped_cont,
const key_compare& comp = key_compare());
template<class Allocator>
flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const Allocator& a);
template<class Allocator>
flat_multimap(sorted_equivalent_t s, const key_container_type& key_cont,
const mapped_container_type& mapped_cont, const key_compare& comp,
const Allocator& a);
template<class Allocator>
flat_multimap(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_multimap(const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(InputIterator first, InputIterator last, const key_compare& comp,
const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multimap(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
const Allocator& a);
template<class Allocator>
flat_multimap(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multimap(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multimap(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
class Predicate>
typename flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>::size_type
erase_if(flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
explicit flat_set(container_type cont, const key_compare& comp = key_compare());
template<class Allocator>
flat_set(const container_type& cont, const Allocator& a);
template<class Allocator>
flat_set(const container_type& cont, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t s, const container_type& cont, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t s, const container_type& cont,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_set(const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(InputIterator first, InputIterator last, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_set(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_set(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(sorted_unique_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_set(sorted_unique_t, InputIterator first, InputIterator last, const Allocator& a);
template<class Allocator>
flat_set(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_set(sorted_unique_t, initializer_list<value_type> il, const Allocator& a);
template<class K> pair<iterator, bool> insert(K&& x);
template<class K> iterator insert(const_iterator hint, K&& x);
template<class InputIterator>
void insert(InputIterator first, InputIterator last);
template<class InputIterator>
void insert(sorted_unique_t, InputIterator first, InputIterator last);
template<container-compatible-range<value_type> R>
void insert_range(R&& rg);
void swap(flat_set& y) noexcept;
container_type extract() &&;
void replace(container_type&& cont);
template<class Key, class Compare, class KeyContainer, class Predicate>
typename flat_set<Key, Compare, KeyContainer>::size_type
erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
explicit flat_multiset(container_type cont, const key_compare& comp = key_compare());
template<class Allocator>
flat_multiset(const container_type& cont, const Allocator& a);
template<class Allocator>
flat_multiset(const container_type& cont, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t s, const container_type& cont, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t s, const container_type& cont,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(const key_compare& comp, const Allocator& a);
template<class Allocator>
explicit flat_multiset(const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(InputIterator first, InputIterator last, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multiset(from_range_t, R&& rg, const Allocator& a);
template<container-compatible-range<value_type> R, class Allocator>
flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
const key_compare& comp, const Allocator& a);
template<class InputIterator, class Allocator>
flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last, const Allocator& a);
template<class Allocator>
flat_multiset(initializer_list<value_type> il, const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(initializer_list<value_type> il, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
const key_compare& comp, const Allocator& a);
template<class Allocator>
flat_multiset(sorted_equivalent_t, initializer_list<value_type> il, const Allocator& a);
template<class... Args> iterator emplace(Args&&... args);
template<class InputIterator>
void insert(InputIterator first, InputIterator last);
template<class InputIterator>
void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
void swap(flat_multiset& y) noexcept;
container_type extract() &&;
void replace(container_type&& cont);
template<class Key, class Compare, class KeyContainer, class Predicate>
typename flat_multiset<Key, Compare, KeyContainer>::size_type
erase_if(flat_multiset<Key, Compare, KeyContainer>& c, Predicate pred);
template<class ParseContext>
constexpr typename ParseContext::iterator
parse(ParseContext& ctx);
template<class FormatContext>
typename FormatContext::iterator
format(maybe-const-adaptor& r, FormatContext& ctx) const;
constexpr span() noexcept;
template<class It>
constexpr explicit(extent != dynamic_extent) span(It first, size_type count);
template<class It, class End>
constexpr explicit(extent != dynamic_extent) span(It first, End last);
template<size_t N> constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
template<class T, size_t N> constexpr span(array<T, N>& arr) noexcept;
template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;
template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
constexpr span(const span& other) noexcept = default;
template<class OtherElementType, size_t OtherExtent>
constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
constexpr span& operator=(const span& other) noexcept = default;
template<class It, class EndOrSize>
span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
template<class R>
span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
template<size_t Count> constexpr span<element_type, Count> first() const;
template<size_t Count> constexpr span<element_type, Count> last() const;
template<size_t Offset, size_t Count = dynamic_extent>
constexpr span<element_type, see below> subspan() const;
constexpr span<element_type, dynamic_extent> first(size_type count) const;
constexpr span<element_type, dynamic_extent> last(size_type count) const;
constexpr span<element_type, dynamic_extent> subspan(
size_type offset, size_type count = dynamic_extent) const;
constexpr size_type size() const noexcept;
constexpr size_type size_bytes() const noexcept;
[[nodiscard]] constexpr bool empty() const noexcept;
constexpr reference operator[](size_type idx) const;
constexpr reference front() const;
constexpr reference back() const;
constexpr pointer data() const noexcept;
constexpr iterator begin() const noexcept;
constexpr iterator end() const noexcept;
constexpr reverse_iterator rbegin() const noexcept;
constexpr reverse_iterator rend() const noexcept;
template<class ElementType, size_t Extent>
span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
as_bytes(span<ElementType, Extent> s) noexcept;
template<class ElementType, size_t Extent>
span<byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
as_writable_bytes(span<ElementType, Extent> s) noexcept;
static constexpr rank_type dynamic-index(rank_type i) noexcept;
static constexpr rank_type dynamic-index-inv(rank_type i) noexcept;
constexpr size_t fwd-prod-of-extents(rank_type i) const noexcept;
constexpr size_t rev-prod-of-extents(rank_type i) const noexcept;
template<class OtherIndexType>
static constexpr auto index-cast(OtherIndexType&& i) noexcept;
template<class OtherIndexType, size_t... OtherExtents>
constexpr explicit(see below)
extents(const extents<OtherIndexType, OtherExtents...>& other) noexcept;
template<class... OtherIndexTypes>
constexpr explicit extents(OtherIndexTypes... exts) noexcept;
template<class OtherIndexType, size_t N>
constexpr explicit(N != rank_dynamic())
extents(span<OtherIndexType, N> exts) noexcept;
template<class OtherIndexType, size_t N>
constexpr explicit(N != rank_dynamic())
extents(const array<OtherIndexType, N>& exts) noexcept;
template<class... Integrals>
explicit extents(Integrals...) -> see below;
static constexpr size_t static_extent(rank_type i) noexcept;
constexpr index_type extent(rank_type i) const noexcept;
template<class OtherIndexType, size_t... OtherExtents>
friend constexpr bool operator==(const extents& lhs,
const extents<OtherIndexType, OtherExtents...>& rhs) noexcept;
template<class IndexType, size_t Rank>
using dextents = see below;
typename M::extents_type
typename M::index_type
typename M::rank_type
typename M::layout_type
m.extents()
m(i...)
m(i...) == m(static_cast<typename M::index_type>(i)...)
m.required_span_size()
m.is_unique()
m.is_exhaustive()
m.is_strided()
m.stride(r)
M::is_always_unique()
M::is_always_exhaustive()
M::is_always_strided()
constexpr mapping(const extents_type& e) noexcept;
template<class OtherExtents>
constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
mapping(const mapping<OtherExtents>& other) noexcept;
template<class OtherExents>
constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
mapping(const layout_right::mapping<OtherExtents>& other) noexcept;
template<class OtherExtents>
constexpr explicit(extents_type::rank() > 0)
mapping(const layout_stride::mapping<OtherExtents>& other);
constexpr index_type required_span_size() const noexcept;
template<class... Indices>
constexpr index_type operator()(Indices... i) const noexcept;
constexpr index_type stride(rank_type i) const;
template<class OtherExtents>
friend constexpr bool operator==(const mapping& x, const mapping<OtherExtents>& y) noexcept;
constexpr mapping(const extents_type& e) noexcept;
template<class OtherExtents>
constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
mapping(const mapping<OtherExtents>& other) noexcept;
template<class OtherExtents>
constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
mapping(const layout_left::mapping<OtherExtents>& other) noexcept;
template<class OtherExtents>
constexpr explicit(extents_type::rank() > 0)
mapping(const layout_stride::mapping<OtherExtents>& other) noexcept;
index_type required_span_size() const noexcept;
template<class... Indices>
constexpr index_type operator()(Indices... i) const noexcept;
constexpr index_type stride(rank_type i) const noexcept;
template<class OtherExtents>
friend constexpr bool operator==(const mapping& x, const mapping<OtherExtents>& y) noexcept;
constexpr mapping() noexcept;
template<class OtherIndexType>
constexpr mapping(const extents_type& e, span<OtherIndexType, rank_> s) noexcept;
template<class OtherIndexType>
constexpr mapping(const extents_type& e, const array<OtherIndexType, rank_>& s) noexcept;
template<class StridedLayoutMapping>
constexpr explicit(see below)
mapping(const StridedLayoutMapping& other) noexcept;
constexpr index_type required_span_size() const noexcept;
template<class... Indices>
constexpr index_type operator()(Indices... i) const noexcept;
constexpr bool is_exhaustive() const noexcept;
template<class OtherMapping>
friend constexpr bool operator==(const mapping& x, const OtherMapping& y) noexcept;
typename A::element_type
typename A::data_handle_type
typename A::reference
typename A::offset_policy
a.access(p, i)
a.offset(p, i)
template<class OtherElementType>
constexpr default_accessor(default_accessor<OtherElementType>) noexcept {}
constexpr reference access(data_handle_type p, size_t i) const noexcept;
constexpr data_handle_type offset(data_handle_type p, size_t i) const noexcept;
constexpr mdspan();
template<class... OtherIndexTypes>
constexpr explicit mdspan(data_handle_type p, OtherIndexTypes... exts);
template<class OtherIndexType, size_t N>
constexpr explicit(N != rank_dynamic())
mdspan(data_handle_type p, span<OtherIndexType, N> exts);
template<class OtherIndexType, size_t N>
constexpr explicit(N != rank_dynamic())
mdspan(data_handle_type p, const array<OtherIndexType, N>& exts);
constexpr mdspan(data_handle_type p, const extents_type& ext);
constexpr mdspan(data_handle_type p, const mapping_type& m);
constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);
template<class OtherElementType, class OtherExtents,
class OtherLayoutPolicy, class OtherAccessor>
constexpr explicit(see below)
mdspan(const mdspan<OtherElementType, OtherExtents,
OtherLayoutPolicy, OtherAccessor>& other);
template<class... OtherIndexTypes>
constexpr reference operator[](OtherIndexTypes... indices) const;
template<class OtherIndexType>
constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
template<class OtherIndexType>
constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
constexpr size_type size() const noexcept;
[[nodiscard]] constexpr bool empty() const noexcept;
friend constexpr void swap(mdspan& x, mdspan& y) noexcept;