`span` (Clase, Biblioteca estándar de C++)

Artículo
04/03/2023

Proporciona una vista ligera sobre una secuencia contigua de objetos. span proporciona una manera segura de recorrer en iteración objetos organizados de forma consecutiva en la memoria y de indizarlos. Por ejemplo, los objetos almacenados en una matriz integrada, std::array o std::vector.

Si normalmente accede a una secuencia de objetos contiguos mediante un puntero y un índice, span es una alternativa más segura y ligera.

El tamaño de span se puede establecer en tiempo de compilación si se especifica como argumento de plantilla, o en tiempo de ejecución si se especifica dynamic_extent.

Sintaxis

template<class T, size_t Extent = dynamic_extent>
class span;

Parámetros de plantilla

T
Tipo de los elementos de span.

Extent
Número de elementos de span si se especifica en tiempo de compilación. De lo contrario, std::dynamic_extent si el número de elementos se va a especificar en tiempo de ejecución.

Guía de deducción

Miembros

Definiciones de tipos	Descripción
`const_pointer`	Tipo de un puntero a un elemento de `const`.
`const_reference`	Tipo de una referencia a un elemento de `const`.
`difference_type`	El tipo de una distancia con signo entre dos elementos.
`element_type`	Tipo de un elemento de `span`.
`iterator`	Tipo de un iterador para `span`.
`pointer`	El tipo de un puntero a un elemento.
`reference`	El tipo de una referencia a un elemento.
`reverse_iterator`	Tipo de un iterador inverso para `span`.
`size_type`	Tipo del resultado de la distancia sin signo entre dos elementos de `span`.
`value_type`	Tipo de un elemento, sin calificaciones `const` o `volatile`.
Constructor	Descripción
`span`	Construya un elemento `span`.
Compatibilidad de iterador	Descripción
`begin`	Obtiene un iterador que apunta al primer elemento de `span`.
`end`	Obtiene un iterador que apunta al final de `span`.
`rbegin`	Obtiene un iterador inverso que apunta al último elemento de `span`; es decir, el principio del objeto `span` inverso.
`rend`	Obtiene un iterador inverso que apunta al principio de `span`; es decir, el final del objeto `span` inverso.
Elementos de acceso	Descripción
`back`	Obtiene el último elemento de `span`.
`data`	Obtiene la dirección del primer elemento de `span`.
`front`	Obtiene el primer elemento de `span`.
`operator[]`	Accede a un elemento en una posición especificada.
Observadores	Descripción
`empty`	Comprueba si el objeto `span` está vacío.
`size`	Obtiene el número de elementos de `span`.
`size_bytes`	Obtiene el tamaño de `span` en bytes.
Subviews	Descripción
`first`	Obtiene un subintervalo del principio de `span`.
`last`	Obtiene un subintervalo del final de `span`.
`subspan`	Obtiene un subintervalo de cualquier lugar de `span`.
Operadores	Descripción
`span::operator=`	Sustituye `span`.
`span::operator[]`	Obtiene el elemento que se encuentra en la posición especificada.

Comentarios

Todas las funciones miembro de span tienen complejidad de tiempo constante.

A diferencia de array o vector, span no "posee" los elementos que contiene. span no libera ningún almacenamiento para los elementos que contiene porque no posee el almacenamiento de esos objetos.

Requisitos

Encabezado: <span> (desde C++20)

Espacio de nombres: std

Opción del compilador: /std:c++20 o posterior es necesaria.

`span::back`

Obtiene el último elemento de span.

constexpr reference back() const noexcept;

Valor devuelto

Referencia al último elemento de span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    cout << mySpan.back();
}

`span::begin`

Obtiene un iterador que apunta al primer elemento de span.

constexpr iterator begin() const noexcept;

Valor devuelto

Iterador que apunta al primer elemento de span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    auto i = mySpan.begin();
    cout << *i;
}

`span::data`

Obtiene un puntero al principio de los datos de span.

constexpr pointer data() const noexcept;

Valor devuelto

Puntero al primer elemento almacenado en span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);
    auto i = mySpan.data();
    cout << *i;
}

`span::difference_type`

Número de elementos entre dos elementos de span.

using difference_type = std::ptrdiff_t;

Ejemplo

#include <span>
#include <iostream>

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    span<int>::difference_type distance = mySpan.end() - mySpan.begin();
    cout << distance << std::endl;
}

`span::element_type`

Tipo de los elementos de span.

using element_type = T;

Comentarios

El tipo se toma del parámetro de plantilla T cuando se crea span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    span<int>::element_type et = mySpan[2];
    cout << et << endl;
}

`span::empty`

Si span contiene elementos.

constexpr bool empty() const noexcept;

Valor devuelto

Devuelve true si this->size() == 0. De lo contrario, falsees .

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);
    bool isEmpty = mySpan.empty(); // isEmpty == false
}

`span::end`

Obtiene un iterador al final de span.

constexpr iterator end() const noexcept;

Valor devuelto

Iterador que apunta justo después del final de span.

Comentarios

end se usa para probar si un iterador ha sobrepasado el final de su intervalo.

No deje de hacer referencia al valor devuelto por este iterador. Úselo para identificar si el iterador ha alcanzado un punto más allá del último elemento de span.

Ejemplo

// Iteration
for (auto it = s1.begin(); it != s1.end(); ++it)
{
    cout << *it;
}

`span::first`

Obtiene un subintervalo tomado del principio de span.

constexpr auto first(size_type count) const noexcept;
template <size_t count> constexpr auto first() const noexcept;

Parámetros

count
Número de elementos del principio de span que se van a colocar en el subintervalo.
El número de elementos se especifica como parámetro de la plantilla, o de la función, como se muestra a continuación.

Valor devuelto

span que contiene count elementos del principio de span.

Comentarios

Use la versión de plantilla de esta función cuando sea posible para validar count en tiempo de compilación y para conservar información sobre span, ya que devuelve un objeto span de extensión fija.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    auto first2 = mySpan.first(2);
    cout << "mySpan.first(2): ";
    for (auto& i : first2)
    {
        cout << i;
    }

    cout << "\nmySpan.first<2>: ";
    auto viewSpan = mySpan.first<2>();
    for (auto& i : viewSpan)
    {
        cout << i;
    }
}

mySpan.first(2): 01
mySpan.first<2>: 01

`span::front`

Obtiene el primer elemento de span.

constexpr reference front() const noexcept;

Valor devuelto

Referencia al primer elemento de span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    auto i = mySpan.front();
    cout << i;
}

`span::iterator`

Tipo de un objeto iterator sobre elementos de span.

using iterator = implementation-defined-iterator-type;

Comentarios

Este tipo actúa como un objeto iterator sobre los elementos de span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    span<int>::iterator it = mySpan.begin();
    cout << *it++ << *it++ << *it;
}

`span::last`

Obtiene un subintervalo tomado del final de span.

constexpr span<element_type, dynamic_extent> last(const size_type count) const noexcept;
template <size_t count> constexpr span<element_type, count> last() const noexcept;

Parámetros

count
Número de elementos del final de span que se van a colocar en el subintervalo. El número se puede especificar como parámetro de la plantilla, o de la función, como se muestra a continuación.

Valor devuelto

span que contiene los últimos count elementos de este objeto span.

Comentarios

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    auto first2 = mySpan.last(2);
    cout << "mySpan.last(2): ";
    for (auto& i : last2)
    {
        cout << i;
    }

    cout << "\nmySpan.last<2>: ";
    auto viewSpan = mySpan.last<2>();
    for (auto& i : viewSpan)
    {
        cout << i;
    }
}

mySpan.last(2): 12
mySpan.last<2>: 12

`span::operator[]`

Obtiene el elemento de span que se encuentra en una posición especificada.

constexpr reference operator[](size_type offset) const;

Parámetros

offset
Elemento basado en cero del objeto span al que se va a acceder.

Valor devuelto

Referencia al elemento en la posición offset. Si la posición no es válida, el comportamiento es indefinido.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);
    cout << mySpan[1];
}

`span::operator=`

Asigne otro span a este.

constexpr span& operator=(const span& other) noexcept = default;

Parámetros

other
span que se va a asignar a este.

Valor devuelto

*this

Comentarios

La asignación realiza una copia superficial del puntero de datos y el tamaño. Una copia superficial es segura porque span no asigna memoria para los elementos que contiene.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);
    span<int> mySpan2;
    mySpan2 = mySpan;
    for (auto &i : mySpan2)
    {
        cout << it;
    }
}

`span::pointer`

Tipos de un puntero y puntero const a un elemento de span.

using pointer = T*;
using const_pointer = const T*;

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    // pointer
    span<int>::pointer ptr = &mySpan[2];
    *ptr = 9;
    cout << mySpan[2];

    // const pointer
    span<int>::const_pointer cPtr = &mySpan[0];
    // *cPtr = 9; error - const
    cout << *cPtr;
}

`span::rbegin`

Obtiene un iterador inverso que apunta al último elemento de span.

constexpr reverse_iterator rbegin() const noexcept;

Valor devuelto

Iterador que apunta al principio del objeto span inverso.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    for (auto rIt = s1.rbegin(); rIt != s1.rend(); ++rIt)
    {
        cout << *rIt;
    }
}

`span::reference`

Tipos de una referencia y referencia const a un elemento de span.

using reference = T&;
using const_reference = const T&;

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    // reference
    span<int>::reference ref = mySpan[0];
    ref = 9;
    cout << mySpan[0];
    // const reference
    span<int>::const_reference cRef = mySpan[1];
    // cRef = 9; error because const
    cout << cRef;
}

`span::rend`

Obtiene un iterador de acceso aleatorio que apunta justo después del final del objeto span inverso.

constexpr reverse_iterator rend() const noexcept;

Valor devuelto

Iterador inverso al marcador de posición que sigue al último elemento del objeto span inverso; es decir, el marcador de posición situado antes del primer elemento del objeto span sin invertir.

Comentarios

rend se usa con un span invertido igual que span::end se usa con un span. Úselo para comprobar si un iterador inverso ha llegado al final de su span.

El valor devuelto por rend no se debe desreferenciar.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    for (auto rIt = s1.rbegin(); rIt != s1.rend(); ++rIt)
    {
        cout << *rIt;
    }
}

`span::reverse_iterator`

Tipo de un iterador inverso para span.

using reverse_iterator = std::reverse_iterator<iterator>;

Ejemplo

#include <span>
#include <iostream>

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    span<int>::reverse_iterator rIt = mySpan.rbegin();
    cout << *rIt++ << *rIt++ << *rIt;
}

`span::size`

Obtiene el número de elementos de span.

constexpr size_t size() const noexcept;

Valor devuelto

Número de elementos incluidos en span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);
    cout << mySpan.size();
}

`span::size_bytes`

Obtiene el tamaño de los elementos de span en bytes.

constexpr size_type size_bytes() const noexcept;

Valor devuelto

Número de bytes que ocupan todos los elementos de span; es decir, sizeof(element_type) multiplicado por el número de elementos de span.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);
    cout << mySpan.size_bytes(); // 3 elements * 4 (size of an int)
}

`span::size_type`

Tipo sin signo adecuado para almacenar el número de elementos de span.

using size_type = size_t;

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    span<int>::size_type szType = mySpan.size();
    cout << szType;
}

`span::span`

Constructores de span.

constexpr span() noexcept
requires (Extent == 0 || Extent == dynamic_extent) = default;

template <class It>
constexpr explicit(Extent != dynamic_extent)
span(It first, size_type count) noexcept

template <class It, class End>
constexpr explicit(Extent != dynamic_extent)
span(It first, End last) noexcept(noexcept(last - first))

template <class T, size_t N>
requires (Extent == dynamic_extent || Extent == N) && is_convertible_v<T (*)[], T (*)[]>
constexpr span(array<T, N>& arr) noexcept

template <class T, size_t N>
requires (Extent == dynamic_extent || Extent == N) && is_convertible_v<const T (*)[], T (*)[]>
constexpr span(const array<T, N>& arr) noexcept

template <size_t N>
requires (Extent == dynamic_extent || Extent == N)
constexpr span(type_identity_t<T> (&arr)[N]) noexcept

template <class R>
constexpr explicit(Extent != dynamic_extent)
span(R&& r)

// default copy ctor
constexpr span(const span& other) noexcept = default;

// converting  ctor
template <class T, size_t OtherExtent>
requires (Extent == dynamic_extent || OtherExtent == dynamic_extent ||
              Extent == OtherExtent) && is_convertible_v<T (*)[], T (*)[]>
constexpr explicit(Extent != dynamic_extent && OtherExtent == dynamic_extent)
span(const span<T, OtherExtent>& other) noexcept

Parámetros

arr
Construye un objeto span partir de una matriz.

count
Número de elementos que habrá en span.

first
Iterador al primer elemento de span.

last
Iterador justo después del último elemento de span.

N
Número de elementos que habrá en span.

other
Realiza una copia de span.

r
Construye span a partir del intervalo R.

Comentarios

span no libera almacenamiento para los elementos de span porque no posee el almacenamiento de los objetos que contiene.

Constructor	Descripción
`span()`	Construye un objeto `span` vacío. Solo se considera durante la resolución de una sobrecarga si el parámetro de plantilla `Extent` es `0` o `dynamic_extent`.
`span(It first, size_type count)`	Construye un objeto `span` a partir de los primeros `count` elementos del iterador `first`. Solo se considera durante la resolución de una sobrecarga si el parámetro de plantilla `Extent` no es `dynamic_extent`.
`span(It first, End last)`	Construye un objeto `span` a partir de los elementos del iterador `first` hasta que se alcanza el final de `last`. Solo se considera durante la resolución de una sobrecarga si el parámetro de plantilla `Extent` no es `dynamic_extent`. `It` debe ser `contiguous_iterator`.
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Construye un objeto `span` a partir de `N` elementos de la matriz especificada. Solo se considera durante la resolución de una sobrecarga si el parámetro de plantilla `Extent` es `dynamic_extent` o igual que `N`.
`span(R&& r)`	Construye un objeto `span` a partir de un intervalo. Solo participa en la resolución de una sobrecarga si el parámetro de plantilla `Extent` no es `dynamic_extent`.
`span(const span& other)`	Constructor de copia generado por el compilador. Una copia superficial del puntero de datos es segura porque `span` no asigna la memoria para contener los elementos.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Constructor de conversión: construye un objeto `span` a partir de otro `span`. Solo participa en la resolución de una sobrecarga si el parámetro de plantilla `Extent` es `dynamic_extent`, o `N` es `dynamic_extent` o igual que `Extent`.

Ejemplo

#include <span>

using namespace std;

int main()
{
    const int MAX=10;

    int x[MAX];
    for (int i = 0; i < MAX; i++)
    {
        x[i] = i;
    }

    span<int, MAX> span1{ x }; // fixed-size span: compiler error if size of x doesn't match template argument MAX
    span<int> span2{ x }; // size is inferred from x
    span<const int> span3 = span2; // converting constructor
    span<int> span4( span2 ); // copy constructor
}

`span::subspan`

Obtiene un subintervalo de span.

constexpr auto subspan(size_type offset, size_type count = dynamic_extent) const noexcept;

template <size_t offset, size_t count = dynamic_extent>
constexpr auto subspan() const noexcept

Parámetros

count
Número de elementos que se van a colocar en el subintervalo. Si count es dynamic_extent (el valor predeterminado), el subintervalo se toma de offset, al final de span.

offset
La ubicación en span para iniciar el subintervalo.

Valor devuelto

span a partir de offset en span. Contiene count elementos.

Comentarios

Hay disponible una versión de plantilla de esta función que comprueba el recuento en tiempo de compilación, que conserva información sobre span mediante la devolución de un objeto span de extensión fija.

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    cout << "mySpan.subspan(1,2): ";
    for (auto& i : mySpan.subspan(1,2))
    {
        cout << i;
    }
    cout << "\nmySpan.subspan<1,2>: ";
    for (auto& i : mySpan.subspan<1,2>())
    {
        cout << i;
    }
    cout << "\nmySpan.subspan<1>: ";
    for (auto& i : mySpan.subspan<1>)
    {
        cout << i;
    }
}

mySpan.subspan(1,2): 12
mySpan.subspan<1,2>: 12
mySpan.subspan<1>: 12

`span::value_type`

Tipo del elemento en span, sin calificaciones const o volatile.

using value_type = std::remove_cv_t<T>;

Ejemplo

#include <span>
#include <iostream>

using namespace std;

int main()
{
    int a[] = { 0,1,2 };
    span<int> mySpan(a);

    span<int>::value_type vType = mySpan[2];
    cout << vType;
}

Guías de deducción

Se proporcionan las siguientes guías de deducción para span.

// Allows the extent to be deduced from std::array and C++ built-in arrays

template <class T, size_t Extent>
span(T (&)[Extent]) -> span<T, Extent>;

template <class T, size_t Size>
span(array<T, Size>&) -> span<T, Size>;

template <class T, size_t Size>
span(const array<T, Size>&) -> span<const T, Size>;

// Allows the element type to be deduced from the iterator and the end of the span.
// The iterator must be contiguous

template <contiguous_iterator It, class End>
span(It, End) -> span<remove_reference_t<iter_reference_t<It>>>;

// Allows the element type to be deduced from a range.
// The range must be contiguous

template <ranges::contiguous_range Rng>
span(Rng &&) -> span<remove_reference_t<ranges::range_reference_t<Rng>>>;

Consulte también

<span>
Procedimiento para usar la deducción de argumentos de plantilla de clase

Compartir vía

span (Clase, Biblioteca estándar de C++)

Sintaxis

Parámetros de plantilla

Miembros

Comentarios

Requisitos

span::back

Valor devuelto

Ejemplo

span::begin

Valor devuelto

Ejemplo

span::data

Valor devuelto

Ejemplo

span::difference_type

Ejemplo

span::element_type

Comentarios

Ejemplo

span::empty

Valor devuelto

Ejemplo

span::end

Valor devuelto

Comentarios

Ejemplo

span::first

Parámetros

Valor devuelto

Comentarios

Ejemplo

span::front

Valor devuelto

Ejemplo

span::iterator

Comentarios

Ejemplo

span::last

Parámetros

Valor devuelto

Comentarios

Ejemplo

span::operator[]

Parámetros

Valor devuelto

Ejemplo

span::operator=

Parámetros

Valor devuelto

Comentarios

Ejemplo

span::pointer

Ejemplo

span::rbegin

Valor devuelto

Ejemplo

span::reference

Ejemplo

span::rend

Valor devuelto

Comentarios

Ejemplo

span::reverse_iterator

Ejemplo

span::size

Valor devuelto

Ejemplo

span::size_bytes

Valor devuelto

Ejemplo

span::size_type

Ejemplo

span::span

Parámetros

Comentarios

Ejemplo

span::subspan

Parámetros

`span` (Clase, Biblioteca estándar de C++)

`span::back`

`span::begin`

`span::data`

`span::difference_type`

`span::element_type`

`span::empty`

`span::end`

`span::first`

`span::front`

`span::iterator`

`span::last`

`span::operator[]`

`span::operator=`

`span::pointer`

`span::rbegin`

`span::reference`

`span::rend`

`span::reverse_iterator`

`span::size`

`span::size_bytes`

`span::size_type`

`span::span`

`span::subspan`

`span::value_type`