标准库标头 <mdspan> (C++23)

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏 (C++20)

语言支持库

概念库 (C++20)

元编程库 (C++11)

诊断库

通用工具库

字符串库

容器库

迭代器库

范围库 (C++20)

算法库

数值库

本地化库

输入/输出库

文件系统库 (C++17)

正则表达式库 (C++11)

并发支持库 (C++11)

技术规范

符号索引

外部库

 

标准库标头

语言支持
<cstddef> <cstdlib> <version> (C++20) <limits> <climits>	<cfloat> <cstdint> (C++11) <stdfloat> (C++23) <new> <typeinfo>	<source_location> (C++20) <exception> <initializer_list> (C++11) <compare> (C++20)	<coroutine> (C++20) <csignal> <csetjmp> <cstdarg>
概念
<concepts> (C++20)
诊断
<stdexcept> <stacktrace> (C++23)	<cassert>	<cerrno>	<system_error> (C++11)
内存管理
<memory>	<memory_resource> (C++17)	<scoped_allocator> (C++11)
元编程
<type_traits> (C++11)	<ratio> (C++11)
通用工具
<utility> <tuple> (C++11) <optional> (C++17) <variant> (C++17)	<any> (C++17) <debugging> (C++26) <expected> (C++23) <bitset>	<functional> <typeindex> (C++11) <execution> (C++17)	<charconv> (C++17) <format> (C++20) <bit> (C++20)
字符串
<string_view> (C++17) <string>	<cctype> <cwctype>	<cstring> <cwchar>	<cuchar> (C++11)
容器
<array> (C++11) <deque> <forward_list> (C++11) <list>	<vector> <map> <set> <unordered_map> (C++11)	<unordered_set> (C++11) <queue> <stack> <flat_map> (C++23)	<flat_set> (C++23) <span> (C++20) <mdspan> (C++23) <inplace_vector> (C++26)
迭代器
<iterator>
范围
<ranges> (C++20)	<generator> (C++23)
算法
<algorithm>	<numeric>
数值
<cfenv> (C++11) <complex>	<random> (C++11) <valarray>	<cmath> <linalg> (C++26)	<numbers> (C++20)
日期时间
<chrono> (C++11)	<ctime>
本地化
<locale>	<clocale>	<codecvt> (C++11/17/26*)	<text_encoding> (C++26)
输入/输出
<iosfwd> <iostream> <ios> <streambuf>	<istream> <ostream> <iomanip> <print> (C++23)	<sstream> <spanstream> (C++23) <fstream> <syncstream> (C++20)	<filesystem> (C++17) <cstdio> <cinttypes> (C++11) <strstream> (C++98/26*)
正则表达式
<regex> (C++11)
并发支持
<stop_token> (C++20) <thread> (C++11) <atomic> (C++11) <rcu> (C++26)	<stdatomic.h> (C++23) <mutex> (C++11) <shared_mutex> (C++14)	<condition_variable> (C++11)   <semaphore> (C++20) <latch> (C++20)	<barrier> (C++20) <future> (C++11) <hazard_pointer> (C++26)
C 兼容
<cstdbool> (C++11/17/20*)   <ccomplex> (C++11/17/20*)	<ctgmath> (C++11/17/20*)	<cstdalign> (C++11/17/20*)	<ciso646> (C++20 前)

 

此头文件是容器库的一部分。

类
mdspan (C++23)	多维非拥有数组视图 (类模板)
extents (C++23)	某秩多维索引空间的一个描述符 (类模板)
layout_left (C++23)	列优先多维数组布局映射策略；最左边的尺度具有步幅 1 (类)
layout_right (C++23)	行优先多维数组布局映射策略；最右边的尺度具有步幅 1 (类)
layout_stride (C++23)	具有用户自定义步长的布局映射策略 (类)
layout_left_padded (C++26)	具有可大于或等于最左侧尺度的填充跨步的列主序布局映射策略 (类)
layout_right_padded (C++26)	具有可大于或等于最右侧尺度的填充跨步的行主序布局映射策略 (类)
default_accessor (C++23)	指示索引访问 mdspan 元素的方式的类型 (类模板)
strided_slice (C++26)	切片说明符，表示一组按照偏移量、尺度和跨步三值指定的有规律分布的索引 (类模板)
submdspan_mapping_result (C++26)	各 submdspan_mapping 重载的返回类型 (类模板)
别名模板
dextentsdims (C++23)(C++26)	全动态 std::extents 的方便别名模板 (别名模板)
函数
submdspan_extents (C++26)	从现存 extents 和分片说明符创建新的 extents (函数模板)
submdspan (C++26)	返回现存 mdspan 的子集上的视图 (函数模板)
标签
full_extentfull_extent_t (C++26)	切片说明符标签，描述指定尺度的全部索引范围 (标签)

概要

namespace std {
  // 类模板 extents
  template<class IndexType, size_t... Extents>
    class extents;
 
  // 别名模板 dextents
  template<class IndexType, size_t Rank>
    using dextents = /* 见描述 */;
 
  // 布局映射
  struct layout_left;
  struct layout_right;
  struct layout_stride;
 
  // 类模板 default_accessor
  template<class ElementType>
    class default_accessor;
 
  // 类模板 mdspan
  template<class ElementType, class Extents, class LayoutPolicy = layout_right,
           class AccessorPolicy = default_accessor<ElementType>>
    class mdspan;
 
  // 创建 submdspan
  template<class OffsetType, class LengthType, class StrideType>
    struct strided_slice;
 
  template<class LayoutMapping>
    struct submdspan_mapping_result;
 
  struct full_extent_t { explicit full_extent_t() = default; };
  inline constexpr full_extent_t full_extent{};
 
  template<class IndexType, class... Extents, class... SliceSpecifiers>
    constexpr auto submdspan_extents(const extents<IndexType, Extents...>&, 
                                     SliceSpecifiers...);
 
  // 函数模板 submdspan
  template<class ElementType, class Extents, class LayoutPolicy,
           class AccessorPolicy, class... SliceSpecifiers>
    constexpr auto submdspan(
      const mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>& src,
      SliceSpecifiers... slices) -> /* 见描述 */;
 
  template<class T>
    concept /*integral-constant-like*/ =        // 仅用于阐释
      is_integral_v<decltype(T::value)> &&
      !is_same_v<bool, remove_const_t<decltype(T::value)>> &&
      convertible_to<T, decltype(T::value)> &&
      equality_comparable_with<T, decltype(T::value)> &&
      bool_constant<T() == T::value>::value &&
      bool_constant<static_cast<decltype(T::value)>(T()) == T::value>::value;
 
  template<class T, class IndexType>
    concept /*index-pair-like*/ =               // 仅用于阐释
      /*pair-like*/<T> &&
      convertible_to<tuple_element_t<0, T>, IndexType> &&
      convertible_to<tuple_element_t<1, T>, IndexType>;
}

类模板 std::mdspan

namespace std {
  template<class ElementType, class Extents, class LayoutPolicy, class AccessorPolicy>
  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); }
 
    // 构造函数
    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(/* 见描述 */)
        mdspan(const mdspan<OtherElementType, OtherExtents,
                            OtherLayoutPolicy, OtherAccessorPolicy>& other);
 
    constexpr mdspan& operator=(const mdspan& rhs) = default;
    constexpr mdspan& operator=(mdspan&& rhs) = default;
 
    // 成员
    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;
    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_;         // 仅用于阐释
    mapping_type map_;          // 仅用于阐释
    data_handle_type ptr_;      // 仅用于阐释
  };
 
  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>;
}

类模板 std::extents

namespace std {
  template<class IndexType, size_t... Extents>
  class extents {
  public:
    using index_type = IndexType;
    using size_type = make_unsigned_t<index_type>;
    using rank_type = size_t;
 
    // 多维索引空间的观察器
    static constexpr rank_type rank() noexcept { return sizeof...(Extents); }
    static constexpr rank_type rank_dynamic() noexcept {
        return /*dynamic-index*/(rank()); }
    static constexpr size_t static_extent(rank_type) noexcept;
    constexpr index_type extent(rank_type) const noexcept;
 
    // 构造函数
    constexpr extents() noexcept = default;
 
    template<class OtherIndexType, size_t... OtherExtents>
      constexpr explicit(/* 见描述 */)
        extents(const extents<OtherIndexType, OtherExtents...>&) noexcept;
    template<class... OtherIndexTypes>
      constexpr explicit extents(OtherIndexTypes...) noexcept;
    template<class OtherIndexType, size_t N>
      constexpr explicit(N != rank_dynamic())
        extents(span<OtherIndexType, N>) noexcept;
    template<class OtherIndexType, size_t N>
      constexpr explicit(N != rank_dynamic())
        extents(const array<OtherIndexType, N>&) noexcept;
 
    // 比较运算符
    template<class OtherIndexType, size_t... OtherExtents>
      friend constexpr bool operator==(const extents&,
                                       const extents<OtherIndexType,
                                       OtherExtents...>&) noexcept;
 
    // 仅用于阐释的辅助工具
    constexpr size_t /*fwd-prod-of-extents*/(rank_type) const noexcept; // 仅用于阐释
    constexpr size_t /*rev-prod-of-extents*/(rank_type) const noexcept; // 仅用于阐释
    template<class OtherIndexType>
      static constexpr auto /*index-cast*/(OtherIndexType&&) noexcept;  // 仅用于阐释
 
  private:
    static constexpr rank_type /*dynamic-index*/(rank_type) noexcept;   // 仅用于阐释
    static constexpr rank_type
        /*dynamic-index-inv*/(rank_type) noexcept;                      // 仅用于阐释
    array<index_type, rank_dynamic()>/*dynamic-extents*/{};             // 仅用于阐释
  };
 
  template<class... Integrals>
    explicit extents(Integrals...)
      -> /* 见描述 */;
}

布局映射策略

namespace std {
  struct layout_left {
    template<class Extents>
      class mapping;
  };
  struct layout_right {
    template<class Extents>
      class mapping;
  };
  struct layout_stride {
    template<class Extents>
      class mapping;
  };
}

类模板 std::layout_left::mapping

namespace std {
  template<class Extents>
  class layout_left::mapping {
  public:
    using extents_type = Extents;
    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 layout_type = layout_left;
 
    // 构造函数
    constexpr mapping() noexcept = default;
    constexpr mapping(const mapping&) noexcept = default;
    constexpr mapping(const extents_type&) noexcept;
    template<class OtherExtents>
      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
        mapping(const mapping<OtherExtents>&) noexcept;
    template<class OtherExtents>
      constexpr explicit(/* 见描述 */)
        mapping(const layout_right::mapping<OtherExtents>&) noexcept;
    template<class OtherExtents>
      explicit(extents_type::rank() > 0)
      constexpr mapping(const layout_stride::mapping<OtherExtents>&);
 
    constexpr mapping& operator=(const mapping&) noexcept = default;
 
    // 观察器
    constexpr const extents_type& extents() const noexcept { return extents_; }
 
    constexpr index_type required_span_size() const noexcept;
 
    template<class... Indices>
      constexpr index_type operator()(Indices...) const noexcept;
 
    static constexpr bool is_always_unique() noexcept { return true; }
    static constexpr bool is_always_exhaustive() noexcept { return true; }
    static constexpr bool is_always_strided() noexcept { return true; }
 
    static constexpr bool is_unique() noexcept { return true; }
    static constexpr bool is_exhaustive() noexcept { return true; }
    static constexpr bool is_strided() noexcept { return true; }
 
    constexpr index_type stride(rank_type) const noexcept;
 
    template<class OtherExtents>
      friend constexpr bool operator==(const mapping&,
                                       const mapping<OtherExtents>&) noexcept;
 
  private:
    extents_type extents_{};    // 仅用于阐释
 
    // submdspan 映射的特化
    template<class... SliceSpecifiers>
      constexpr auto /*submdspan-mapping-impl*/(                // 仅用于阐释
        SliceSpecifiers... slices) const -> /* 见描述 */;
 
    template<class... SliceSpecifiers>
      friend constexpr auto submdspan_mapping(
        const mapping& src, SliceSpecifiers... slices) {
          return src./*submdspan-mapping-impl*/(slices...);
      }
  };
}

类模板 std::layout_right::mapping

namespace std {
  template<class Extents>
  class layout_right::mapping {
  public:
    using extents_type = Extents;
    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 layout_type = layout_right;
 
    // 构造函数
    constexpr mapping() noexcept = default;
    constexpr mapping(const mapping&) noexcept = default;
    constexpr mapping(const extents_type&) noexcept;
    template<class OtherExtents>
      constexpr explicit(!is_convertible_v<OtherExtents, extents_type>)
        mapping(const mapping<OtherExtents>&) noexcept;
    template<class OtherExtents>
      constexpr explicit(/* 见描述 */)
        mapping(const layout_left::mapping<OtherExtents>&) noexcept;
    template<class OtherExtents>
      constexpr explicit(extents_type::rank() > 0)
        mapping(const layout_stride::mapping<OtherExtents>&) noexcept;
 
    constexpr mapping& operator=(const mapping&) noexcept = default;
 
    // 观察器
    constexpr const extents_type& extents() const noexcept { return extents_; }
 
    constexpr index_type required_span_size() const noexcept;
 
    template<class... Indices>
      constexpr index_type operator()(Indices...) const noexcept;
 
    static constexpr bool is_always_unique() noexcept { return true; }
    static constexpr bool is_always_exhaustive() noexcept { return true; }
    static constexpr bool is_always_strided() noexcept { return true; }
 
    static constexpr bool is_unique() noexcept { return true; }
    static constexpr bool is_exhaustive() noexcept { return true; }
    static constexpr bool is_strided() noexcept { return true; }
 
    constexpr index_type stride(rank_type) const noexcept;
 
    template<class OtherExtents>
      friend constexpr bool operator==(const mapping&, 
                                       const mapping<OtherExtents>&) noexcept;
 
  private:
    extents_type extents_{};    // 仅用于阐释
 
    // submdspan 映射的特化
    template<class... SliceSpecifiers>
      constexpr auto /*submdspan-mapping-impl*/(                // 仅用于阐释
        SliceSpecifiers... slices) const -> /* 见描述 */;
 
    template<class... SliceSpecifiers>
      friend constexpr auto submdspan_mapping(
        const mapping& src, SliceSpecifiers... slices) {
          return src./*submdspan-mapping-impl*/(slices...);
      }
  };
}

类模板 std::layout_stride::mapping

namespace std {
  template<class Extents>
  class layout_stride::mapping {
  public:
    using extents_type = Extents;
    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 layout_type = layout_stride;
 
  private:
    static constexpr rank_type rank_ = extents_type::rank();    // 仅用于阐释
 
  public:
    // 构造函数
    constexpr mapping() noexcept = default;
    constexpr mapping(const mapping&) noexcept = default;
    template<class OtherIndexType>
      constexpr mapping(const extents_type&, span<OtherIndexType, rank_>) noexcept;
    template<class OtherIndexType>
      constexpr mapping(const extents_type&, const array<OtherIndexType, 
                        rank_>&) noexcept;
 
    template<class StridedLayoutMapping>
      constexpr explicit(/* 见描述 */) mapping(
          const StridedLayoutMapping&) noexcept;
 
    constexpr mapping& operator=(const mapping&) noexcept = default;
 
    // 观察器
    constexpr const extents_type& extents() const noexcept { return extents_; }
    constexpr array<index_type, rank_> strides() const noexcept { return strides_; }
 
    constexpr index_type required_span_size() const noexcept;
 
    template<class... Indices>
      constexpr index_type operator()(Indices...) const noexcept;
 
    static constexpr bool is_always_unique() noexcept { return true; }
    static constexpr bool is_always_exhaustive() noexcept { return false; }
    static constexpr bool is_always_strided() noexcept { return true; }
 
    static constexpr bool is_unique() noexcept { return true; }
    constexpr bool is_exhaustive() const noexcept;
    static constexpr bool is_strided() noexcept { return true; }
 
    constexpr index_type stride(rank_type i) const noexcept { return strides_[i]; }
 
    template<class OtherMapping>
      friend constexpr bool operator==(const mapping&, const OtherMapping&) noexcept;
 
  private:
    extents_type extents_{};                     // 仅用于阐释
    array<index_type, rank_> strides_{};         // 仅用于阐释
 
    // submdspan 映射的特化
    template<class... SliceSpecifiers>
      constexpr auto /*submdspan-mapping-impl*/(                // 仅用于阐释
        SliceSpecifiers... slices) const -> /* 见描述 */;
 
    template<class... SliceSpecifiers>
      friend constexpr auto submdspan_mapping(
        const mapping& src, SliceSpecifiers... slices) {
          return src./*submdspan-mapping-impl*/(slices...);
      }
  };
}

仅用于阐释的辅助工具

template<class T>
  constexpr bool /*is-extents*/ = false;                              // 仅用于阐释
template<class SizeType, size_t... Args>
  constexpr bool /*is-extents*/<extents<IndexType, Args...>> = true;  // 仅用于阐释
 
template<class M>
concept /*layout-mapping-alike*/ = requires {                         // 仅用于阐释
  requires /*is-extents*/<typename M::extents_type>;
  { M::is_always_strided() } -> same_as<bool>;
  { M::is_always_exhaustive() } -> same_as<bool>;
  { M::is_always_unique() } -> same_as<bool>;
  bool_constant<M::is_always_strided()>::value;
  bool_constant<M::is_always_exhaustive()>::value;
  bool_constant<M::is_always_unique()>::value;
};
 
template<class T>
  constexpr T /*de-ice*/(T val) { return val; }                       // 仅用于阐释
template</*integral-constant-like*/ T>
  constexpr auto /*de-ice*/(T) { return T::value; }                   // 仅用于阐释
 
template<class IndexType, size_t k, class... SliceSpecifiers>
  constexpr IndexType /*first_*/(SliceSpecifiers... slices);          // 仅用于阐释
 
template<size_t k, class Extents, class... SliceSpecifiers>           // 仅用于阐释
  constexpr auto /*last_*/(const Extents& src, SliceSpecifiers... slices); 
 
template<class IndexType, size_t N, class... SliceSpecifiers>         // 仅用于阐释
  constexpr array<IndexType, sizeof...(SliceSpecifiers)>
    /*src-indices*/(const array<IndexType, N>& indices, SliceSpecifiers... slices);

类模板 std::default_accessor

namespace std {
  template<class ElementType>
  struct default_accessor {
    using offset_policy = default_accessor;
    using element_type = ElementType;
    using reference = ElementType&;
    using data_handle_type = ElementType*;
 
    constexpr default_accessor() noexcept = default;
    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;
  };
}

类模板 std::strided_slice

namespace std {
  template<class OffsetType, class ExtentType, class StrideType>
  struct strided_slice {
    using offset_type = OffsetType;
    using extent_type = ExtentType;
    using stride_type = StrideType;
 
    [[no_unique_address]] offset_type offset{};
    [[no_unique_address]] extent_type extent{};
    [[no_unique_address]] stride_type stride{};
  };
}

类模板 std::submdspan_mapping_result

namespace std {
  template<class LayoutMapping>
  struct submdspan_mapping_result {
    [[no_unique_address]] LayoutMapping mapping = LayoutMapping();
    size_t offset{};
  };
}

参考

• C++23 标准（ISO/IEC 14882:2024）：

• 24.7.4 Header <mdspan> synopsis [mdspan.syn]