24
Containers library
[containers]
24.7
Views
[views]
24.7.3
Multidimensional access
[views.multidim]
24.7.3.6
Class template
mdspan
[mdspan.mdspan]
24.7.3.6.1
Overview
[mdspan.mdspan.overview]
1
#
mdspan
is a view of a multidimensional array of elements
.
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, extents
<
size_t,
maybe-static-ext
<
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
>
;
}
2
#
Mandates
:
(2.1)
ElementType
is a complete object type that is neither an abstract class type nor an array type,
(2.2)
Extents
is a specialization of
extents
, and
(2.3)
is_
same_
v
<
ElementType,
typename
AccessorPolicy
::
element_
type
>
is
true
.
3
#
LayoutPolicy
shall meet the layout mapping policy requirements (
[mdspan.
layout.
policy.
reqmts]
), and
AccessorPolicy
shall meet the accessor policy requirements (
[mdspan.
accessor.
reqmts]
)
.
4
#
Each specialization
MDS
of
mdspan
models
copyable
and
(4.1)
is_
nothrow_
move_
constructible_
v
<
MDS
>
is
true
,
(4.2)
is_
nothrow_
move_
assignable_
v
<
MDS
>
is
true
, and
(4.3)
is_
nothrow_
swappable_
v
<
MDS
>
is
true
.
5
#
A specialization of
mdspan
is a trivially copyable type if its
accessor_
type
,
mapping_
type
, and
data_
handle_
type
are trivially copyable types
.