Namespaces
Variants

std::span<T,Extent>:: span

From cppreference.net
constexpr span ( ) noexcept ;
(1) (desde C++20)
template < class It >

explicit ( extent ! = std:: dynamic_extent )

constexpr span ( It first, size_type count ) ;
(2) (desde C++20)
template < class It, class End >

explicit ( extent ! = std:: dynamic_extent )

constexpr span ( It first, End last ) ;
(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 )

constexpr span ( R && r ) ;
(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 )

constexpr span ( const std:: span < U, N > & source ) noexcept ;
(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 :

1) extent == std:: dynamic_extent || extent == 0
4-6) extent == std:: dynamic_extent || extent == N
9) extent == std:: dynamic_extent || N == std:: dynamic_extent || extent == N


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 :

  • Si la implementación está hardened , ocurre una contract violation . Además, si el manejador de violación de contrato retorna bajo semántica de evaluación "observe", el comportamiento es indefinido.
  • Si la implementación no está hardened, el comportamiento es indefinido.
(desde C++26)
2) extent == std:: dynamic_extent || extent == count
3) extent == std:: dynamic_extent || extent == last - first
7) extent == std:: dynamic_extent || extent == ranges:: size ( r )
8) extent == std:: dynamic_extent || extent == il. size ( )
9) extent == std:: dynamic_extent || extent == source. size ( )

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:

4-6) std:: remove_pointer_t < decltype ( std:: data ( arr ) ) >
9) 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

2) Si [ first , first + count ) no es un rango válido , el comportamiento es indefinido.
3) Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_convertible_v < End, std:: size_t > es false .
Si [ first , last ) no es un rango válido, el comportamiento es indefinido.
7) Esta sobrecarga participa en la resolución de sobrecarga solo si se cumplen todas las siguientes condiciones:
8) Esta sobrecarga participa en la resolución de sobrecarga solo si std:: is_const_v < element_type > es true .

Excepciones

2) No lanza nada.
3) Lanza qué y cuándo last - first lanza.
7) Lanza qué y cuándo std :: ranges:: size ( r ) y std :: ranges:: data ( r ) lanzan.

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)