`span` classe (libreria standard C++)

Articolo
10/12/2023

Fornisce una visualizzazione leggera su una sequenza contigua di oggetti. Un span oggetto fornisce un modo sicuro per scorrere e indicizzare in oggetti disposti in memoria. Ad esempio, gli oggetti archiviati in una matrice predefinita, std::arrayo std::vector.

Se in genere si accede a una sequenza di oggetti back-to-back usando un puntatore e un indice, un è span un'alternativa più sicura e leggera.

Le dimensioni di un span oggetto possono essere impostate in fase di compilazione specificandolo come argomento modello o in fase di esecuzione specificando dynamic_extent.

Sintassi

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

Parametri del modello

T
Tipo degli elementi contenuti nell'oggetto span.

Extent
Numero di elementi nell'oggetto span se specificato in fase di compilazione. In caso contrario std::dynamic_extent , se il numero di elementi verrà specificato in fase di esecuzione.

Guida alla deduzione

Membri

Definizioni di tipo	Descrizione
`const_pointer`	Tipo di un puntatore a un `const` elemento.
`const_reference`	Tipo di un riferimento a un `const` elemento.
`difference_type`	Tipo di una distanza Signed tra due elementi.
`element_type`	Tipo di un `span` elemento.
`iterator`	Tipo di iteratore per un oggetto `span`.
`pointer`	Tipo di un puntatore a un elemento.
`reference`	Tipo di un riferimento a un elemento.
`reverse_iterator`	Tipo di iteratore inverso per un oggetto `span`.
`size_type`	Tipo per il risultato della distanza senza segno tra due elementi in `span`.
`value_type`	Tipo di un elemento, senza `const` o `volatile` qualifiche.
Costruttore	Descrizione
`span`	Creare un oggetto `span`.
Supporto iteratore	Descrizione
`begin`	Ottiene un iteratore che punta al primo elemento dell'oggetto `span`.
`end`	Ottenere un iteratore che punta alla fine di `span`.
`rbegin`	Ottiene un iteratore inverso che punta all'ultimo elemento dell'oggetto `span`, ovvero all'inizio dell'oggetto invertito `span`.
`rend`	Ottiene un iteratore inverso che punta alla parte anteriore dell'oggetto `span`, ovvero alla fine dell'oggetto invertito `span`.
Elementi di accesso	Descrizione
`back`	Ottiene l'ultimo elemento nell'oggetto `span`.
`data`	Ottenere l'indirizzo del primo elemento nell'oggetto `span`.
`front`	Ottenere il primo elemento nell'oggetto `span`.
`operator[]`	Accedere a un elemento in una posizione specificata.
Osservatori	Descrizione
`empty`	Verificare se l'oggetto `span` è vuoto.
`size`	Ottiene il numero di elementi nell'oggetto `span`.
`size_bytes`	Ottiene le dimensioni in `span` byte.
Visualizzazioni secondarie	Descrizione
`first`	Ottenere un sottopan dalla parte anteriore di `span`.
`last`	Ottenere un sottopan dalla parte posteriore di `span`.
`subspan`	Ottenere un sottopan da qualsiasi punto dell'oggetto `span`.
Operatori	Descrizione
`span::operator=`	Sostituire .`span`
`span::operator[]`	Ottiene l'elemento nella posizione specificata.

Osservazioni:

Tutte le span funzioni membro hanno una complessità temporale costante.

A differenza di array o vector, un span oggetto non è "proprietario" degli elementi al suo interno. Un span oggetto non libera alcuna risorsa di archiviazione per gli elementi all'interno di esso perché non possiede lo spazio di archiviazione per tali oggetti.

Requisiti

Intestazione: <span> (da C++20)

Spazio dei nomi: std

Opzione del compilatore: /std:c++20 o versione successiva è obbligatoria.

`span::back`

Ottiene l'ultimo elemento nell'oggetto span.

constexpr reference back() const noexcept;

Valore restituito

Riferimento all'ultimo elemento nell'oggetto span.

Esempio

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

Ottiene un iteratore che punta al primo elemento dell'oggetto span.

constexpr iterator begin() const noexcept;

Valore restituito

Iteratore che punta al primo elemento dell'oggetto span.

Esempio

#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`

Ottenere un puntatore all'inizio dei span dati.

constexpr pointer data() const noexcept;

Valore restituito

Puntatore al primo elemento archiviato spanin .

Esempio

#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`

Numero di elementi tra due elementi in un oggetto span.

using difference_type = std::ptrdiff_t;

Esempio

#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 degli elementi contenuti nell'oggetto span.

using element_type = T;

Osservazioni:

Il tipo viene ricavato dal parametro del modello T quando viene creato un oggetto span .

Esempio

#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`

Indica se contiene span elementi.

constexpr bool empty() const noexcept;

Valore restituito

Restituisce true se this->size() == 0. In caso contrario, false.

Esempio

#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`

Ottenere un iteratore alla fine di span.

constexpr iterator end() const noexcept;

Valore restituito

Iteratore che punta poco oltre la fine dell'oggetto span.

Osservazioni:

end viene utilizzato per verificare se un iteratore ha superato la fine del relativo intervallo.

Non dereferenziare il valore restituito da questo iteratore. Usarlo per identificare se l'iteratore è stato raggiunto oltre l'ultimo elemento dell'oggetto span.

Esempio

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

`span::first`

Ottenere un sottopan, ricavato dalla parte anteriore di questo spanoggetto .

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

Parametri

count
Numero di elementi dalla parte anteriore di questa span classe da inserire nel sottopan.
Il numero di elementi viene specificato come parametro per il modello o per la funzione, come illustrato di seguito.

Valore restituito

Oggetto span che contiene count elementi dalla parte anteriore di questo spanoggetto .

Osservazioni:

Usare la versione del modello di questa funzione quando possibile per convalidare l'oggetto count in fase di compilazione e mantenere le informazioni su span poiché restituisce un span extent fisso.

Esempio

#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`

Ottenere il primo elemento nell'oggetto span.

constexpr reference front() const noexcept;

Valore restituito

Riferimento al primo elemento dell'oggetto span.

Esempio

#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 di un iterator elemento over span .

using iterator = implementation-defined-iterator-type;

Osservazioni:

Questo tipo funge da iterator oggetto sugli elementi di un oggetto span.

Esempio

#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`

Ottenere una sottospan, ricavata dalla fine di questo spanoggetto .

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;

Parametri

count
Numero di elementi dalla fine span da inserire nel sottopan. Il numero può essere specificato come parametro per il modello o per la funzione, come illustrato di seguito.

Valore restituito

Oggetto span contenente gli ultimi count elementi di questo spanoggetto .

Osservazioni:

Esempio

#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[]`

Ottiene l'elemento in span in corrispondenza di una posizione specificata.

constexpr reference operator[](size_type offset) const;

Parametri

offset
Elemento in base zero nell'oggetto span a cui accedere.

Valore restituito

Riferimento all'elemento in corrispondenza della posizione offset. Se la posizione non è valida, il comportamento non è definito.

Esempio

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Assegna un altro span a questo.

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

Parametri

other
Oggetto span da assegnare a questo.

Valore restituito

*this

Osservazioni:

L'assegnazione esegue una copia superficiale del puntatore dati e delle dimensioni. Una copia superficiale è sicura perché non span alloca memoria per gli elementi contenuti.

Esempio

#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`

Tipi per un puntatore e const un puntatore a un span elemento .

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

Esempio

#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`

Ottiene un iteratore inverso che punta all'ultimo elemento di .span

constexpr reverse_iterator rbegin() const noexcept;

Valore restituito

Iteratore che punta all'inizio dell'oggetto invertito span.

Esempio

#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`

Tipi per un riferimento e un const riferimento a un span elemento .

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

Esempio

#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`

Ottenere un iteratore ad accesso casuale che punta appena oltre la fine dell'oggetto invertito span.

constexpr reverse_iterator rend() const noexcept;

Valore restituito

Iteratore inverso al segnaposto che segue l'ultimo elemento nell'oggetto invertito span, ovvero il segnaposto prima del primo elemento dell'oggetto non invertito span.

Osservazioni:

rend viene usato con un oggetto invertito span esattamente come span::end viene usato con un oggetto span. Usarlo per verificare se un iteratore inverso ha raggiunto la fine del relativo span.

Il valore restituito da rend non deve essere dereferenziato.

Esempio

#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 di iteratore inverso per un oggetto span.

using reverse_iterator = std::reverse_iterator<iterator>;

Esempio

#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`

Ottiene il numero di elementi nell'oggetto span.

constexpr size_t size() const noexcept;

Valore restituito

Numero di elementi in span.

Esempio

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Ottiene le dimensioni degli elementi in span byte.

constexpr size_type size_bytes() const noexcept;

Valore restituito

Numero di byte che tutti gli elementi nell'oggetto span occupano, ovvero moltiplicati sizeof(element_type) per il numero di elementi nell'oggetto span.

Esempio

#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 senza segno, adatto per archiviare il numero di elementi in un oggetto span.

using size_type = size_t;

Esempio

#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`

span Costruttori.

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

Parametri

arr
Costruire un oggetto span da una matrice.

count
Numero di elementi che saranno inclusi nell'oggetto span.

first
Iteratore al primo elemento dell'oggetto span.

last
Iteratore per superare l'ultimo elemento nell'oggetto span.

N
Numero di elementi che saranno inclusi nell'oggetto span.

other
Creare una copia di questo spanoggetto .

r
Costruire un oggetto span dall'intervallo R.

Osservazioni:

Un span oggetto non libera spazio di archiviazione per gli elementi in span perché non è proprietario dello spazio di archiviazione degli oggetti all'interno di esso.

Costruttore	Descrizione
`span()`	Costruire un oggetto vuoto `span`. Viene considerato solo durante la risoluzione dell'overload quando il parametro del modello `Extent` è `0` o `dynamic_extent`.
`span(It first, size_type count)`	Costruire un `span` oggetto dai primi `count` elementi dall'iteratore `first`. Viene considerato solo durante la risoluzione dell'overload quando il parametro del modello `Extent` non `dynamic_extent`è .
`span(It first, End last)`	Costruire un `span` oggetto dagli elementi nell'iteratore `first` fino a raggiungere la fine `last` . Viene considerato solo durante la risoluzione dell'overload quando il parametro del modello `Extent` non `dynamic_extent`è . `It` deve essere un `contiguous_iterator`.
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Costruire un oggetto `span` da `N` elementi della matrice specificata. Viene considerato solo durante la risoluzione dell'overload quando il parametro del modello `Extent` è `dynamic_extent` o è uguale a `N`.
`span(R&& r)`	Costruire un oggetto `span` da un intervallo. Partecipa alla risoluzione dell'overload solo se il parametro del modello `Extent` non `dynamic_extent`è .
`span(const span& other)`	Costruttore di copia generato dal compilatore. Una copia superficiale del puntatore dati è sicura perché `span` non alloca la memoria per contenere gli elementi.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Conversione del costruttore: costruire un `span` oggetto da un altro `span`oggetto . Partecipa alla risoluzione dell'overload solo se il parametro del modello `Extent` è `dynamic_extent`o `N` è `dynamic_extent` o è uguale a `Extent`.

Esempio

#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`

Ottenere un sottopanno di questo spanoggetto .

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

Parametri

count
Numero di elementi da inserire nel sottopan. Se count è dynamic_extent (il valore predefinito), il sottopan viene ricavato dalla offset fine di questo spanoggetto .

offset
Posizione in questo span oggetto per avviare l'intervallo secondario.

Valore restituito

Oggetto span a offset partire da in questo spanoggetto . Contiene count elementi.

Osservazioni:

È disponibile una versione del modello di questa funzione che controlla il conteggio in fase di compilazione, che mantiene le informazioni sull'oggetto span restituendo un span extent fisso.

Esempio

#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 dell'elemento in span, senza const o volatile qualifiche.

using value_type = std::remove_cv_t<T>;

Esempio

#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;
}

Guide alla deduzione

Le guide di deduzione seguenti sono disponibili per 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>>>;

Vedi anche

<span>
Come usare la deduzione dell'argomento del modello di classe

Condividi tramite

span classe (libreria standard C++)

Sintassi

Parametri del modello

Membri

Osservazioni:

Requisiti

span::back

Valore restituito

Esempio

span::begin

Valore restituito

Esempio

span::data

Valore restituito

Esempio

span::difference_type

Esempio

span::element_type

Osservazioni:

Esempio

span::empty

Valore restituito

Esempio

span::end

Valore restituito

Osservazioni:

Esempio

span::first

Parametri

Valore restituito

Osservazioni:

Esempio

span::front

Valore restituito

Esempio

span::iterator

Osservazioni:

Esempio

span::last

Parametri

Valore restituito

Osservazioni:

Esempio

span::operator[]

Parametri

Valore restituito

Esempio

span::operator=

Parametri

Valore restituito

Osservazioni:

Esempio

span::pointer

Esempio

span::rbegin

Valore restituito

Esempio

span::reference

Esempio

span::rend

Valore restituito

Osservazioni:

Esempio

span::reverse_iterator

Esempio

span::size

Valore restituito

Esempio

span::size_bytes

Valore restituito

Esempio

span::size_type

Esempio

span::span

Parametri

Osservazioni:

Esempio

span::subspan

Parametri

`span` classe (libreria standard 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`