std::span<T,Extent>:: span
|
constexpr
span
(
)
noexcept
;
|
(1) | (desde C++20) |
|
template
<
class
It
>
explicit
(
extent
!
=
std::
dynamic_extent
)
|
(2) | (desde C++20) |
|
template
<
class
It,
class
End
>
explicit
(
extent
!
=
std::
dynamic_extent
)
|
(3) | (desde C++20) |
|
template
<
std::
size_t
N
>
constexpr span ( std:: type_identity_t < element_type > ( & arr ) [ N ] ) noexcept ; |
(4) | (desde C++20) |
|
template
<
class
U,
std::
size_t
N
>
constexpr span ( std:: array < U, N > & arr ) noexcept ; |
(5) | (desde C++20) |
|
template
<
class
U,
std::
size_t
N
>
constexpr span ( const std:: array < U, N > & arr ) noexcept ; |
(6) | (desde C++20) |
|
template
<
class
R
>
explicit
(
extent
!
=
std::
dynamic_extent
)
|
(7) | (desde C++20) |
|
explicit
(
extent
!
=
std::
dynamic_extent
)
constexpr span ( std:: initializer_list < value_type > il ) noexcept ; |
(8) | (desde C++26) |
|
template
<
class
U,
std::
size_t
N
>
explicit
(
extent
!
=
std::
dynamic_extent
&&
N
==
std::
dynamic_extent
)
|
(9) | (desde C++20) |
|
constexpr
span
(
const
span
&
other
)
noexcept
=
default
;
|
(10) | (desde C++20) |
Construye un
span
.
Contenidos |
Parámetros
| first | - | iterador al primer elemento de la secuencia |
| count | - | número de elementos en la secuencia |
| last | - | iterador después del último elemento de la secuencia u otro centinela |
| arr | - | arreglo para construir una vista |
| r | - | rango para construir una vista |
| source | - |
otro
span
desde el cual convertir
|
| other | - |
otro
span
desde el cual copiar
|
Efectos
| Sobrecarga |
data()
después de la construcción
|
size()
después de la construcción
|
|---|---|---|
| ( 1 ) | nullptr | 0 |
| ( 2 ) | std:: to_address ( first ) | count |
| ( 3 ) | last - first | |
| ( 4 ) | std:: data ( arr ) | N |
| ( 5 ) | ||
| ( 6 ) | ||
| ( 7 ) | ranges:: data ( r ) | ranges:: size ( r ) |
| ( 8 ) | il. begin ( ) | il. size ( ) |
| ( 9 ) | source. data ( ) | source. size ( ) |
| ( 10 ) | other. data ( ) | other. size ( ) |
Restricciones e información complementaria
Requisitos de tamaño
Si
extent
no es
std::
dynamic_extent
y el tamaño del rango fuente es diferente de
extent
, el objeto
span
no puede ser construido.
Estas sobrecargas participan en la resolución de sobrecarga solo si el resultado de la siguiente expresión es true :
|
Si el resultado de la siguiente expresión es false , el comportamiento es indefinido. |
(hasta C++26) |
|
Si el resultado de la siguiente expresión es false :
|
(desde C++26) |
Requisitos de conversión
Si
element_type
es diferente del tipo de elemento del rango fuente, y este último no puede convertirse al primero mediante
conversión de calificación
, el objeto
span
no puede ser construido.
Estas sobrecargas participan en la resolución de sobrecarga solo si
std::
is_convertible_v
<
U
(
*
)
[
]
, element_type
(
*
)
[
]
>
es
true
, donde
U
se define de la siguiente manera:
U
Requisitos de concepto
Si cualquier argumento de plantilla no modela cierto(s) concepto(s), el
span
objeto no puede ser construido.
Estas sobrecargas participan en la resolución de sobrecarga solo si el argumento de plantilla correspondiente al parámetro de plantilla especificado satisface el/los concepto(s) correspondiente(s). Si no cumple con los requisitos semánticos de ningún concepto correspondiente, el comportamiento es indefinido:
| Sobrecarga |
Parámetro
de plantilla |
Concepto | Observación |
|---|---|---|---|
| ( 2 ) |
It
|
contiguous_iterator
|
|
| ( 3 ) |
It
|
contiguous_iterator
|
|
End
|
sized_sentinel_for<It>
|
||
| ( 7 ) |
R
|
contiguous_range
|
|
sized_range
|
|||
borrowed_range
|
solo requerido si std:: is_const_v < element_type > es false |
Otras restricciones
[
first
,
last
)
no es un rango válido, el comportamiento es indefinido.
-
std::
remove_cvref_t
<
R
>
no es una especialización de
std::spano std::array . - std:: is_array_v < std:: remove_cvref_t < R >> es false .
Excepciones
Notas
| Macro de prueba de características | Valor | Estándar | Característica |
|---|---|---|---|
__cpp_lib_span_initializer_list
|
202311L
|
(C++26) |
Construcción de
std::span
desde un
std::initializer_list
,
(
8
)
|
Ejemplo
#include <array> #include <iostream> #include <span> #include <vector> void print_span(std::span<const int> s) { for (int n : s) std::cout << n << ' '; std::cout << '\n'; } int main() { int c[]{1, 2, 3}; print_span(c); // se construye desde un array std::array a{4, 5, 6}; print_span(a); // se construye desde std::array std::vector v{7, 8, 9}; print_span(v); // se construye desde std::vector #if __cpp_lib_span_initializer_list print_span({0, 1, 2}); // se construye desde initializer_list #else print_span({{0, 1, 2}}); // lo mismo, una solución alternativa #endif }
Salida:
1 2 3 4 5 6 7 8 9 0 1 2
Véase también
|
acceso directo al almacenamiento contiguo subyacente
(función miembro pública) |
|
|
devuelve el número de elementos
(función miembro pública) |
|
asigna un
span
(función miembro pública) |
|
|
(C++17)
(C++20)
|
devuelve el tamaño de un contenedor o array
(plantilla de función) |
|
(C++17)
|
obtiene el puntero al array subyacente
(plantilla de función) |