24
Containers library
[containers]
24.7
Views
[views]
24.7.2
Contiguous access
[views.contiguous]
24.7.2.2
Class template
span
[views.span]
24.7.2.2.1
Overview
[span.overview]
1
#
A
span
is a view over a contiguous sequence of objects, the storage of which is owned by some other object
.
2
#
All member functions of
span
have constant time complexity
.
🔗
namespace
std
{
template
<
class
ElementType, size_t Extent
=
dynamic_extent
>
class
span
{
public
:
// constants and types
using
element_type
=
ElementType;
using
value_type
=
remove_cv_t
<
ElementType
>
;
using
size_type
=
size_t;
using
difference_type
=
ptrdiff_t;
using
pointer
=
element_type
*
;
using
const_pointer
=
const
element_type
*
;
using
reference
=
element_type
&
;
using
const_reference
=
const
element_type
&
;
using
iterator
=
implementation-defined
;
// see
[span.
iterators]
using
const_iterator
=
std
::
const_iterator
<
iterator
>
;
using
reverse_iterator
=
std
::
reverse_iterator
<
iterator
>
;
using
const_reverse_iterator
=
std
::
const_iterator
<
reverse_iterator
>
;
static
constexpr
size_type extent
=
Extent;
//
[span.
cons]
, constructors, copy, and assignment
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
explicit
(
extent
!
=
dynamic_extent
)
span
(
std
::
initializer_list
<
value_type
>
il
)
;
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
;
//
[span.
sub]
, subviews
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
;
//
[span.
obs]
, observers
constexpr
size_type size
(
)
const
noexcept
;
constexpr
size_type size_bytes
(
)
const
noexcept
;
constexpr
bool
empty
(
)
const
noexcept
;
//
[span.
elem]
, element access
constexpr
reference
operator
[
]
(
size_type idx
)
const
;
constexpr
reference at
(
size_type idx
)
const
;
// freestanding-deleted
constexpr
reference front
(
)
const
;
constexpr
reference back
(
)
const
;
constexpr
pointer data
(
)
const
noexcept
;
//
[span.
iterators]
, iterator support
constexpr
iterator begin
(
)
const
noexcept
;
constexpr
iterator end
(
)
const
noexcept
;
constexpr
const_iterator cbegin
(
)
const
noexcept
{
return
begin
(
)
;
}
constexpr
const_iterator cend
(
)
const
noexcept
{
return
end
(
)
;
}
constexpr
reverse_iterator rbegin
(
)
const
noexcept
;
constexpr
reverse_iterator rend
(
)
const
noexcept
;
constexpr
const_reverse_iterator crbegin
(
)
const
noexcept
{
return
rbegin
(
)
;
}
constexpr
const_reverse_iterator crend
(
)
const
noexcept
{
return
rend
(
)
;
}
private
:
pointer
data_
;
//
exposition only
size_type
size_
;
//
exposition only
}
;
template
<
class
It,
class
EndOrSize
>
span
(
It, EndOrSize
)
-
>
span
<
remove_reference_t
<
iter_reference_t
<
It
>
>
,
maybe-static-ext
<
EndOrSize
>
>
;
template
<
class
T, size_t N
>
span
(
T
(
&
)
[
N
]
)
-
>
span
<
T, N
>
;
template
<
class
T, size_t N
>
span
(
array
<
T, N
>
&
)
-
>
span
<
T, N
>
;
template
<
class
T, size_t N
>
span
(
const
array
<
T, N
>
&
)
-
>
span
<
const
T, N
>
;
template
<
class
R
>
span
(
R
&
&
)
-
>
span
<
remove_reference_t
<
ranges
::
range_reference_t
<
R
>
>
>
;
}
3
#
span
<
ElementType, Extent
>
is a trivially copyable type (
[basic.
types.
general]
)
.
4
#
ElementType
is required to be a complete object type that is not an abstract class type
.
5
#
For a
span
s
, any operation that invalidates a pointer in the range [
s
.
data
(
)
, s
.
data
(
)
+
s
.
size
(
)
) invalidates pointers, iterators, and references to elements of
s
.