[mdspan.mdspan] - C++20 → C++23

Files changed (1) hide show

tmp/tmpskn5vj0h/{from.md → to.md} +672 -0

tmp/tmpskn5vj0h/{from.md → to.md} RENAMED Viewed

	@@ -0,0 +1,672 @@

+#### Class template `mdspan` <a id="mdspan.mdspan">[[mdspan.mdspan]]</a>
+##### Overview <a id="mdspan.mdspan.overview">[[mdspan.mdspan.overview]]</a>
+`mdspan` is a view of a multidimensional array of elements.
+``` cpp
+namespace std {
+  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
+           class AccessorPolicy = default_accessor<ElementType>>
+  class mdspan {
+  public:
+    using extents_type = Extents;
+    using layout_type = LayoutPolicy;
+    using accessor_type = AccessorPolicy;
+    using mapping_type = typename layout_type::template mapping<extents_type>;
+    using element_type = ElementType;
+    using value_type = remove_cv_t<element_type>;
+    using index_type = typename extents_type::index_type;
+    using size_type = typename extents_type::size_type;
+    using rank_type = typename extents_type::rank_type;
+    using data_handle_type = typename accessor_type::data_handle_type;
+    using reference = typename accessor_type::reference;
+    static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+    static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+    static constexpr size_t static_extent(rank_type r) noexcept
+      { return extents_type::static_extent(r); }
+    constexpr index_type extent(rank_type r) const noexcept { return extents().extent(r); }
+    // [mdspan.mdspan.cons], constructors
+    constexpr mdspan();
+    constexpr mdspan(const mdspan& rhs) = default;
+    constexpr mdspan(mdspan&& rhs) = default;
+    template<class... OtherIndexTypes>
+      constexpr explicit mdspan(data_handle_type ptr, 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 OtherAccessorPolicy>
+      constexpr explicit(see below)
+        mdspan(const mdspan<OtherElementType, OtherExtents,
+                            OtherLayoutPolicy, OtherAccessorPolicy>& other);
+    constexpr mdspan& operator=(const mdspan& rhs) = default;
+    constexpr mdspan& operator=(mdspan&& rhs) = default;
+    // [mdspan.mdspan.members], members
+    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;
+    constexpr const extents_type& extents() const noexcept { return map_.extents(); }
+    constexpr const data_handle_type& data_handle() const noexcept { return ptr_; }
+    constexpr const mapping_type& mapping() const noexcept { return map_; }
+    constexpr const accessor_type& accessor() const noexcept { return acc_; }
+    static constexpr bool is_always_unique()
+      { return mapping_type::is_always_unique(); }
+    static constexpr bool is_always_exhaustive()
+      { return mapping_type::is_always_exhaustive(); }
+    static constexpr bool is_always_strided()
+      { return mapping_type::is_always_strided(); }
+    constexpr bool is_unique() const
+      { return map_.is_unique(); }
+    constexpr bool is_exhaustive() const
+      { return map_.is_exhaustive(); }
+    constexpr bool is_strided() const
+      { return map_.is_strided(); }
+    constexpr index_type stride(rank_type r) const
+      { return map_.stride(r); }
+  private:
+    accessor_type acc_;         // exposition only
+    mapping_type map_;          // exposition only
+    data_handle_type ptr_;      // exposition only
+  };
+  template<class CArray>
+    requires(is_array_v<CArray> && rank_v<CArray> == 1)
+    mdspan(CArray&)
+      -> mdspan<remove_all_extents_t<CArray>, extents<size_t, extent_v<CArray, 0>>>;
+  template<class Pointer>
+    requires(is_pointer_v<remove_reference_t<Pointer>>)
+    mdspan(Pointer&&)
+      -> mdspan<remove_pointer_t<remove_reference_t<Pointer>>, extents<size_t>>;
+  template<class ElementType, class... Integrals>
+    requires((is_convertible_v<Integrals, size_t> && ...) && sizeof...(Integrals) > 0)
+    explicit mdspan(ElementType*, Integrals...)
+      -> mdspan<ElementType, dextents<size_t, sizeof...(Integrals)>>;
+  template<class ElementType, class OtherIndexType, size_t N>
+    mdspan(ElementType*, span<OtherIndexType, N>)
+      -> mdspan<ElementType, dextents<size_t, N>>;
+  template<class ElementType, class OtherIndexType, size_t N>
+    mdspan(ElementType*, const array<OtherIndexType, N>&)
+      -> mdspan<ElementType, dextents<size_t, N>>;
+  template<class ElementType, class IndexType, size_t... ExtentsPack>
+    mdspan(ElementType*, const extents<IndexType, ExtentsPack...>&)
+      -> mdspan<ElementType, extents<IndexType, ExtentsPack...>>;
+  template<class ElementType, class MappingType>
+    mdspan(ElementType*, const MappingType&)
+      -> mdspan<ElementType, typename MappingType::extents_type,
+                typename MappingType::layout_type>;
+  template<class MappingType, class AccessorType>
+    mdspan(const typename AccessorType::data_handle_type&, const MappingType&,
+           const AccessorType&)
+      -> mdspan<typename AccessorType::element_type, typename MappingType::extents_type,
+                typename MappingType::layout_type, AccessorType>;
+}
+```
+*Mandates:*
+- `ElementType` is a complete object type that is neither an abstract
+  class type nor an array type,
+- `Extents` is a specialization of `extents`, and
+- `is_same_v<ElementType, typename AccessorPolicy::element_type>` is
+  `true`.
+`LayoutPolicy` shall meet the layout mapping policy requirements
+[[mdspan.layout.policy.reqmts]], and `AccessorPolicy` shall meet the
+accessor policy requirements [[mdspan.accessor.reqmts]].
+Each specialization `MDS` of `mdspan` models `copyable` and
+- `is_nothrow_move_constructible_v<MDS>` is `true`,
+- `is_nothrow_move_assignable_v<MDS>` is `true`, and
+- `is_nothrow_swappable_v<MDS>` is `true`.
+A specialization of `mdspan` is a trivially copyable type if its
+`accessor_type`, `mapping_type`, and `data_handle_type` are trivially
+copyable types.
+##### Constructors <a id="mdspan.mdspan.cons">[[mdspan.mdspan.cons]]</a>
+``` cpp
+constexpr mdspan();
+```
+*Constraints:*
+- `rank_dynamic() > 0` is `true`.
+- `is_default_constructible_v<data_handle_type>` is `true`.
+- `is_default_constructible_v<mapping_type>` is `true`.
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of *ptr\_* and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:* Value-initializes *ptr\_*, *map\_*, and *acc\_*.
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr explicit mdspan(data_handle_type p, OtherIndexTypes... exts);
+```
+Let `N` be `sizeof...(OtherIndexTypes)`.
+*Constraints:*
+- `(is_convertible_v<OtherIndexTypes, index_type> && ...)` is `true`,
+- `(is_nothrow_constructible<index_type, OtherIndexTypes> && ...)` is
+  `true`,
+- `N == rank() || N == rank_dynamic()` is `true`,
+- `is_constructible_v<mapping_type, extents_type>` is `true`, and
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of `p` and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with
+  `extents_type(static_cast<index_type>(std::move(exts))...)`, and
+- value-initializes *acc\_*.
+``` cpp
+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);
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`,
+- `(is_nothrow_constructible<index_type, const OtherIndexType&> && ...)`
+  is `true`,
+- `N == rank() || N == rank_dynamic()` is `true`,
+- `is_constructible_v<mapping_type, extents_type>` is `true`, and
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of `p` and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `extents_type(exts)`, and
+- value-initializes *acc\_*.
+``` cpp
+constexpr mdspan(data_handle_type p, const extents_type& ext);
+```
+*Constraints:*
+- `is_constructible_v<mapping_type, const extents_type&>` is `true`, and
+- `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* $[0, \texttt{\textit{map_}.required_span_size()})$ is
+an accessible range of `p` and *acc\_* for the values of *map\_* and
+*acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `ext`, and
+- value-initializes *acc\_*.
+``` cpp
+constexpr mdspan(data_handle_type p, const mapping_type& m);
+```
+*Constraints:* `is_default_constructible_v<accessor_type>` is `true`.
+*Preconditions:* [0, `m.required_span_size()`) is an accessible range of
+`p` and *acc\_* for the value of *acc\_* after the invocation of this
+constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `m`, and
+- value-initializes *acc\_*.
+``` cpp
+constexpr mdspan(data_handle_type p, const mapping_type& m, const accessor_type& a);
+```
+*Preconditions:* [0, `m.required_span_size()`) is an accessible range of
+`p` and `a`.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `std::move(p)`,
+- direct-non-list-initializes *map\_* with `m`, and
+- direct-non-list-initializes *acc\_* with `a`.
+``` cpp
+template<class OtherElementType, class OtherExtents,
+         class OtherLayoutPolicy, class OtherAccessor>
+  constexpr explicit(see below)
+    mdspan(const mdspan<OtherElementType, OtherExtents,
+                        OtherLayoutPolicy, OtherAccessor>& other);
+```
+*Constraints:*
+- `is_constructible_v<mapping_type, const OtherLayoutPolicy::template mapping<Oth- erExtents>&>`
+  is `true`, and
+- `is_constructible_v<accessor_type, const OtherAccessor&>` is `true`.
+*Mandates:*
+- `is_constructible_v<data_handle_type, const OtherAccessor::data_handle_type&>`
+  is `true`, and
+- `is_constructible_v<extents_type, OtherExtents>` is `true`.
+*Preconditions:*
+- For each rank index `r` of `extents_type`,
+  `static_extent(r) == dynamic_extent || static_extent(r) == other.extent(r)`
+  is `true`.
+- $[0, \texttt{\textit{map_}.required_span_size()})$ is an accessible
+  range of *ptr\_* and *acc\_* for values of *ptr\_*, *map\_*, and
+  *acc\_* after the invocation of this constructor.
+*Effects:*
+- Direct-non-list-initializes *ptr\_* with `other.`*`ptr_`*,
+- direct-non-list-initializes *map\_* with `other.`*`map_`*, and
+- direct-non-list-initializes *acc\_* with `other.`*`acc_`*.
+*Remarks:* The expression inside `explicit` is equivalent to:
+``` cpp
+!is_convertible_v<const OtherLayoutPolicy::template mapping<OtherExtents>&, mapping_type>
+|| !is_convertible_v<const OtherAccessor&, accessor_type>
+```
+##### Members <a id="mdspan.mdspan.members">[[mdspan.mdspan.members]]</a>
+``` cpp
+template<class... OtherIndexTypes>
+  constexpr reference operator[](OtherIndexTypes... indices) const;
+```
+*Constraints:*
+- `(is_convertible_v<OtherIndexTypes, index_type> && ...)` is `true`,
+- `(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ...)` is
+  `true`, and
+- `sizeof...(OtherIndexTypes) == rank()` is `true`.
+Let `I` be `extents_type::`*`index-cast`*`(std::move(indices))`.
+*Preconditions:* `I` is a multidimensional index in `extents()`.
+[*Note 1*: This implies that
+*`map_`*`(I) < `*`map_`*`.required_span_size()` is
+`true`. — *end note*]
+*Effects:* Equivalent to:
+``` cpp
+return acc_.access(ptr_, map_(static_cast<index_type>(std::move(indices))...));
+```
+``` cpp
+template<class OtherIndexType>
+  constexpr reference operator[](span<OtherIndexType, rank()> indices) const;
+template<class OtherIndexType>
+  constexpr reference operator[](const array<OtherIndexType, rank()>& indices) const;
+```
+*Constraints:*
+- `is_convertible_v<const OtherIndexType&, index_type>` is `true`, and
+- `is_nothrow_constructible_v<index_type, const OtherIndexType&>` is
+  `true`.
+*Effects:* Let `P` be a parameter pack such that
+``` cpp
+is_same_v<make_index_sequence<rank()>, index_sequence<P...>>
+```
+is `true`. Equivalent to:
+``` cpp
+return operator[](as_const(indices[P])...);
+```
+``` cpp
+constexpr size_type size() const noexcept;
+```
+*Preconditions:* The size of the multidimensional index space
+`extents()` is representable as a value of type `size_type`
+[[basic.fundamental]].
+*Returns:* `extents().`*`fwd-prod-of-extents`*`(rank())`.
+``` cpp
+[[nodiscard]] constexpr bool empty() const noexcept;
+```
+*Returns:* `true` if the size of the multidimensional index space
+`extents()` is 0, otherwise `false`.
+``` cpp
+friend constexpr void swap(mdspan& x, mdspan& y) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+swap(x.ptr_, y.ptr_);
+swap(x.map_, y.map_);
+swap(x.acc_, y.acc_);
+```
+<!-- Link reference definitions -->
+[alg.equal]: algorithms.md#alg.equal
+[alg.sorting]: algorithms.md#alg.sorting
+[algorithm.stable]: library.md#algorithm.stable
+[algorithms]: algorithms.md#algorithms
+[algorithms.requirements]: algorithms.md#algorithms.requirements
+[allocator.requirements]: library.md#allocator.requirements
+[allocator.requirements.completeness]: library.md#allocator.requirements.completeness
+[allocator.traits.members]: mem.md#allocator.traits.members
+[allocator.uses.construction]: mem.md#allocator.uses.construction
+[array]: #array
+[array.cons]: #array.cons
+[array.creation]: #array.creation
+[array.members]: #array.members
+[array.overview]: #array.overview
+[array.special]: #array.special
+[array.syn]: #array.syn
+[array.tuple]: #array.tuple
+[array.zero]: #array.zero
+[associative]: #associative
+[associative.general]: #associative.general
+[associative.map.syn]: #associative.map.syn
+[associative.reqmts]: #associative.reqmts
+[associative.reqmts.except]: #associative.reqmts.except
+[associative.reqmts.general]: #associative.reqmts.general
+[associative.set.syn]: #associative.set.syn
+[basic.fundamental]: basic.md#basic.fundamental
+[basic.string]: strings.md#basic.string
+[class.copy.ctor]: class.md#class.copy.ctor
+[class.default.ctor]: class.md#class.default.ctor
+[class.dtor]: class.md#class.dtor
+[container.adaptors]: #container.adaptors
+[container.adaptors.format]: #container.adaptors.format
+[container.adaptors.general]: #container.adaptors.general
+[container.alloc.reqmts]: #container.alloc.reqmts
+[container.gen.reqmts]: #container.gen.reqmts
+[container.insert.return]: #container.insert.return
+[container.node]: #container.node
+[container.node.compat]: #container.node.compat
+[container.node.cons]: #container.node.cons
+[container.node.dtor]: #container.node.dtor
+[container.node.modifiers]: #container.node.modifiers
+[container.node.observers]: #container.node.observers
+[container.node.overview]: #container.node.overview
+[container.opt.reqmts]: #container.opt.reqmts
+[container.reqmts]: #container.reqmts
+[container.requirements]: #container.requirements
+[container.requirements.dataraces]: #container.requirements.dataraces
+[container.requirements.general]: #container.requirements.general
+[container.requirements.pre]: #container.requirements.pre
+[container.rev.reqmts]: #container.rev.reqmts
+[containers]: #containers
+[containers.general]: #containers.general
+[containers.summary]: #containers.summary
+[dcl.init.aggr]: dcl.md#dcl.init.aggr
+[defns.valid]: intro.md#defns.valid
+[deque]: #deque
+[deque.capacity]: #deque.capacity
+[deque.cons]: #deque.cons
+[deque.erasure]: #deque.erasure
+[deque.modifiers]: #deque.modifiers
+[deque.overview]: #deque.overview
+[deque.syn]: #deque.syn
+[expr.const]: expr.md#expr.const
+[flat.map]: #flat.map
+[flat.map.access]: #flat.map.access
+[flat.map.capacity]: #flat.map.capacity
+[flat.map.cons]: #flat.map.cons
+[flat.map.defn]: #flat.map.defn
+[flat.map.erasure]: #flat.map.erasure
+[flat.map.modifiers]: #flat.map.modifiers
+[flat.map.overview]: #flat.map.overview
+[flat.map.syn]: #flat.map.syn
+[flat.multimap]: #flat.multimap
+[flat.multimap.cons]: #flat.multimap.cons
+[flat.multimap.defn]: #flat.multimap.defn
+[flat.multimap.erasure]: #flat.multimap.erasure
+[flat.multimap.overview]: #flat.multimap.overview
+[flat.multiset]: #flat.multiset
+[flat.multiset.cons]: #flat.multiset.cons
+[flat.multiset.defn]: #flat.multiset.defn
+[flat.multiset.erasure]: #flat.multiset.erasure
+[flat.multiset.modifiers]: #flat.multiset.modifiers
+[flat.multiset.overview]: #flat.multiset.overview
+[flat.set]: #flat.set
+[flat.set.cons]: #flat.set.cons
+[flat.set.defn]: #flat.set.defn
+[flat.set.erasure]: #flat.set.erasure
+[flat.set.modifiers]: #flat.set.modifiers
+[flat.set.overview]: #flat.set.overview
+[flat.set.syn]: #flat.set.syn
+[forward.iterators]: iterators.md#forward.iterators
+[forward.list]: #forward.list
+[forward.list.access]: #forward.list.access
+[forward.list.cons]: #forward.list.cons
+[forward.list.erasure]: #forward.list.erasure
+[forward.list.iter]: #forward.list.iter
+[forward.list.modifiers]: #forward.list.modifiers
+[forward.list.ops]: #forward.list.ops
+[forward.list.overview]: #forward.list.overview
+[forward.list.syn]: #forward.list.syn
+[hash.requirements]: library.md#hash.requirements
+[iterator.concept.contiguous]: iterators.md#iterator.concept.contiguous
+[iterator.concept.random.access]: iterators.md#iterator.concept.random.access
+[iterator.requirements]: iterators.md#iterator.requirements
+[iterator.requirements.general]: iterators.md#iterator.requirements.general
+[list]: #list
+[list.capacity]: #list.capacity
+[list.cons]: #list.cons
+[list.erasure]: #list.erasure
+[list.modifiers]: #list.modifiers
+[list.ops]: #list.ops
+[list.overview]: #list.overview
+[list.syn]: #list.syn
+[map]: #map
+[map.access]: #map.access
+[map.cons]: #map.cons
+[map.erasure]: #map.erasure
+[map.modifiers]: #map.modifiers
+[map.overview]: #map.overview
+[mdspan.accessor]: #mdspan.accessor
+[mdspan.accessor.default]: #mdspan.accessor.default
+[mdspan.accessor.default.members]: #mdspan.accessor.default.members
+[mdspan.accessor.default.overview]: #mdspan.accessor.default.overview
+[mdspan.accessor.general]: #mdspan.accessor.general
+[mdspan.accessor.reqmts]: #mdspan.accessor.reqmts
+[mdspan.extents]: #mdspan.extents
+[mdspan.extents.cmp]: #mdspan.extents.cmp
+[mdspan.extents.cons]: #mdspan.extents.cons
+[mdspan.extents.dextents]: #mdspan.extents.dextents
+[mdspan.extents.expo]: #mdspan.extents.expo
+[mdspan.extents.obs]: #mdspan.extents.obs
+[mdspan.extents.overview]: #mdspan.extents.overview
+[mdspan.layout]: #mdspan.layout
+[mdspan.layout.general]: #mdspan.layout.general
+[mdspan.layout.left]: #mdspan.layout.left
+[mdspan.layout.left.cons]: #mdspan.layout.left.cons
+[mdspan.layout.left.obs]: #mdspan.layout.left.obs
+[mdspan.layout.left.overview]: #mdspan.layout.left.overview
+[mdspan.layout.policy.overview]: #mdspan.layout.policy.overview
+[mdspan.layout.policy.reqmts]: #mdspan.layout.policy.reqmts
+[mdspan.layout.reqmts]: #mdspan.layout.reqmts
+[mdspan.layout.right]: #mdspan.layout.right
+[mdspan.layout.right.cons]: #mdspan.layout.right.cons
+[mdspan.layout.right.obs]: #mdspan.layout.right.obs
+[mdspan.layout.right.overview]: #mdspan.layout.right.overview
+[mdspan.layout.stride]: #mdspan.layout.stride
+[mdspan.layout.stride.cons]: #mdspan.layout.stride.cons
+[mdspan.layout.stride.expo]: #mdspan.layout.stride.expo
+[mdspan.layout.stride.obs]: #mdspan.layout.stride.obs
+[mdspan.layout.stride.overview]: #mdspan.layout.stride.overview
+[mdspan.mdspan]: #mdspan.mdspan
+[mdspan.mdspan.cons]: #mdspan.mdspan.cons
+[mdspan.mdspan.members]: #mdspan.mdspan.members
+[mdspan.mdspan.overview]: #mdspan.mdspan.overview
+[mdspan.overview]: #mdspan.overview
+[mdspan.syn]: #mdspan.syn
+[multimap]: #multimap
+[multimap.cons]: #multimap.cons
+[multimap.erasure]: #multimap.erasure
+[multimap.modifiers]: #multimap.modifiers
+[multimap.overview]: #multimap.overview
+[multiset]: #multiset
+[multiset.cons]: #multiset.cons
+[multiset.erasure]: #multiset.erasure
+[multiset.overview]: #multiset.overview
+[priority.queue]: #priority.queue
+[priqueue.cons]: #priqueue.cons
+[priqueue.cons.alloc]: #priqueue.cons.alloc
+[priqueue.members]: #priqueue.members
+[priqueue.overview]: #priqueue.overview
+[priqueue.special]: #priqueue.special
+[queue]: #queue
+[queue.cons]: #queue.cons
+[queue.cons.alloc]: #queue.cons.alloc
+[queue.defn]: #queue.defn
+[queue.mod]: #queue.mod
+[queue.ops]: #queue.ops
+[queue.special]: #queue.special
+[queue.syn]: #queue.syn
+[random.access.iterators]: iterators.md#random.access.iterators
+[res.on.data.races]: library.md#res.on.data.races
+[sequence.reqmts]: #sequence.reqmts
+[sequences]: #sequences
+[sequences.general]: #sequences.general
+[set]: #set
+[set.cons]: #set.cons
+[set.erasure]: #set.erasure
+[set.overview]: #set.overview
+[span.cons]: #span.cons
+[span.deduct]: #span.deduct
+[span.elem]: #span.elem
+[span.iterators]: #span.iterators
+[span.objectrep]: #span.objectrep
+[span.obs]: #span.obs
+[span.overview]: #span.overview
+[span.sub]: #span.sub
+[span.syn]: #span.syn
+[stack]: #stack
+[stack.cons]: #stack.cons
+[stack.cons.alloc]: #stack.cons.alloc
+[stack.defn]: #stack.defn
+[stack.general]: #stack.general
+[stack.mod]: #stack.mod
+[stack.ops]: #stack.ops
+[stack.special]: #stack.special
+[stack.syn]: #stack.syn
+[strings]: strings.md#strings
+[swappable.requirements]: library.md#swappable.requirements
+[temp.deduct]: temp.md#temp.deduct
+[temp.param]: temp.md#temp.param
+[temp.type]: temp.md#temp.type
+[term.trivially.copyable.type]: basic.md#term.trivially.copyable.type
+[unord]: #unord
+[unord.general]: #unord.general
+[unord.hash]: utilities.md#unord.hash
+[unord.map]: #unord.map
+[unord.map.cnstr]: #unord.map.cnstr
+[unord.map.elem]: #unord.map.elem
+[unord.map.erasure]: #unord.map.erasure
+[unord.map.modifiers]: #unord.map.modifiers
+[unord.map.overview]: #unord.map.overview
+[unord.map.syn]: #unord.map.syn
+[unord.multimap]: #unord.multimap
+[unord.multimap.cnstr]: #unord.multimap.cnstr
+[unord.multimap.erasure]: #unord.multimap.erasure
+[unord.multimap.modifiers]: #unord.multimap.modifiers
+[unord.multimap.overview]: #unord.multimap.overview
+[unord.multiset]: #unord.multiset
+[unord.multiset.cnstr]: #unord.multiset.cnstr
+[unord.multiset.erasure]: #unord.multiset.erasure
+[unord.multiset.overview]: #unord.multiset.overview
+[unord.req]: #unord.req
+[unord.req.except]: #unord.req.except
+[unord.req.general]: #unord.req.general
+[unord.set]: #unord.set
+[unord.set.cnstr]: #unord.set.cnstr
+[unord.set.erasure]: #unord.set.erasure
+[unord.set.overview]: #unord.set.overview
+[unord.set.syn]: #unord.set.syn
+[vector]: #vector
+[vector.bool]: #vector.bool
+[vector.bool.fmt]: #vector.bool.fmt
+[vector.bool.pspc]: #vector.bool.pspc
+[vector.capacity]: #vector.capacity
+[vector.cons]: #vector.cons
+[vector.data]: #vector.data
+[vector.erasure]: #vector.erasure
+[vector.modifiers]: #vector.modifiers
+[vector.overview]: #vector.overview
+[vector.syn]: #vector.syn
+[views]: #views
+[views.contiguous]: #views.contiguous
+[views.general]: #views.general
+[views.multidim]: #views.multidim
+[views.span]: #views.span
+[^1]: Equality comparison is a refinement of partitioning if no two
+    objects that compare equal fall into different partitions.
+[^2]: These member functions are only provided by containers whose
+    iterators are random access iterators.
+[^3]: As specified in  [[allocator.requirements]], the requirements in
+    this Clause apply only to lists whose allocators compare equal.
+[^4]: `reserve()` uses `Allocator::allocate()` which can throw an
+    appropriate exception.

Diff to HTML by rtfpessoa