`span` classe (bibliothèque standard C++)

Article
10/12/2023

Fournit une vue légère sur une séquence contiguë d’objets. Un span moyen sûr d’itérer et d’indexer dans des objets qui sont organisés de retour en mémoire. Tels que les objets stockés dans un tableau intégré, std::arrayou std::vector.

Si vous accédez généralement à une séquence d’objets back-to-back à l’aide d’un pointeur et d’un index, il span s’agit d’une alternative plus sûre et légère.

La taille d’un span peut être définie au moment de la compilation en le spécifiant en tant qu’argument de modèle ou au moment de l’exécution en spécifiant dynamic_extent.

Syntaxe

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

Paramètres de modèle

T
Type des éléments dans le span.

Extent
Nombre d’éléments dans le cas où ils sont spécifiés au moment de la span compilation. Sinon std::dynamic_extent , si le nombre d’éléments est spécifié au moment de l’exécution.

Guide de déduction

Membres

Définitions de types	Description
`const_pointer`	Type d’un pointeur vers un `const` élément.
`const_reference`	Type d’une référence à un `const` élément.
`difference_type`	Type d'une distance signée entre deux éléments.
`element_type`	Type d’un `span` élément.
`iterator`	Type d’itérateur pour un `span`.
`pointer`	Type d'un pointeur vers un élément.
`reference`	Type d'une référence à un élément.
`reverse_iterator`	Type d’itérateur inverse pour un `span`.
`size_type`	Type pour le résultat de la distance non signée entre deux éléments dans le `span`.
`value_type`	Type d’un élément, sans `const` ou `volatile` qualification.
Constructeur	Description
`span`	Construisez un `span`.
Prise en charge de l’itérateur	Description
`begin`	Obtenir un itérateur pointant vers le premier élément du `span`.
`end`	Obtenez un itérateur pointant vers la fin du `span`.
`rbegin`	Obtenez un itérateur inverse pointant vers le dernier élément du `span`; autrement dit, le début de l’itérateur inversé `span`.
`rend`	Obtenez un itérateur inverse pointant vers l’avant du `span`; autrement dit, la fin de l’itérateur inversé `span`.
Éléments Access	Description
`back`	Obtenir le dernier élément dans le `span`.
`data`	Obtenez l’adresse du premier élément dans le `span`.
`front`	Obtenir le premier élément dans le `span`.
`operator[]`	Accédez à un élément à une position spécifiée.
Observateurs	Description
`empty`	Testez si la valeur `span` est vide.
`size`	Obtenir le nombre d’éléments dans le `span`.
`size_bytes`	Obtenez la taille des `span` octets.
Sous-vues	Description
`first`	Obtenez un sous-volet à partir de l’avant du `span`.
`last`	Obtenez un sous-volet à partir de l’arrière `span`du .
`subspan`	Obtenez un sous-volet n’importe où dans le `span`.
Opérateurs	Description
`span::operator=`	Remplacez le `span`fichier .
`span::operator[]`	Obtenez l’élément à la position spécifiée.

Notes

Toutes les span fonctions membres ont une complexité de temps constante.

Contrairement array ou vector, un span ne « possède pas » les éléments à l’intérieur de celui-ci. Un span n’libère aucun stockage pour les éléments qu’il contient, car il ne possède pas le stockage pour ces objets.

Spécifications

En-tête : <span> (depuis C++20)

Espace de noms : std

Option du compilateur : /std:c++20 ou version ultérieure est requise.

`span::back`

Obtenir le dernier élément dans le span.

constexpr reference back() const noexcept;

Valeur retournée

Référence au dernier élément du span.

Exemple

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

Obtenir un itérateur pointant vers le premier élément du span.

constexpr iterator begin() const noexcept;

Valeur retournée

Itérateur pointant vers le premier élément du span.

Exemple

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

Obtenez un pointeur vers le début des span données.

constexpr pointer data() const noexcept;

Valeur retournée

Pointeur vers le premier élément stocké dans le span.

Exemple

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

Nombre d’éléments entre deux éléments dans un span.

using difference_type = std::ptrdiff_t;

Exemple

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

Type des éléments dans le span.

using element_type = T;

Notes

Le type est extrait du paramètre T de modèle lors de la création d’un span modèle.

Exemple

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

Indique si les span éléments contiennent.

constexpr bool empty() const noexcept;

Valeur retournée

Retourne true si this->size() == 0. falseSinon.

Exemple

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

Obtenez un itérateur à la fin du span.

constexpr iterator end() const noexcept;

Valeur retournée

Itérateur pointant juste au-delà de la spanfin du .

Notes

end est utilisé pour vérifier si un itérateur a dépassé la fin de la plage.

Ne déréférencez pas la valeur retournée par cet itérateur. Utilisez-la pour identifier si l’itérateur a atteint au-delà du dernier élément du span.

Exemple

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

`span::first`

Obtenez un sous-volet, tiré de l’avant de ce span.

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

Paramètres

count
Nombre d’éléments à partir de l’avant de celui-ci span à placer dans le sous-volet.
Le nombre d’éléments est spécifié en tant que paramètre pour le modèle ou pour la fonction, comme illustré ci-dessous.

Valeur retournée

Qui span contient des count éléments à partir de l’avant de ce span.

Notes

Utilisez la version de modèle de cette fonction lorsque cela est possible pour valider le moment de la count compilation et pour conserver des informations sur la span mesure dans laquelle elle retourne une span étendue fixe.

Exemple

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

Obtenir le premier élément dans le span.

constexpr reference front() const noexcept;

Valeur retournée

Référence au premier élément du span.

Exemple

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

Type d’un iterator sur-éléments span .

using iterator = implementation-defined-iterator-type;

Notes

Ce type sert de iterator sur les éléments d’un span.

Exemple

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

Obtenez un sous-volet, extrait de la fin de ce 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;

Paramètres

count
Nombre d’éléments de la fin span à placer dans le sous-volet. Le nombre peut être spécifié en tant que paramètre pour le modèle ou pour la fonction, comme illustré ci-dessous.

Valeur retournée

Contenant span les derniers count éléments de ce span.

Notes

Exemple

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

Récupérez l’élément à span une position spécifiée.

constexpr reference operator[](size_type offset) const;

Paramètres

offset
Élément de base zéro dans l’accès span .

Valeur retournée

Référence à l’élément à la position offset. Si la position n’est pas valide, le comportement n’est pas défini.

Exemple

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Affectez-en un autre span à celui-ci.

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

Paramètres

other
À span attribuer à celui-ci.

Valeur retournée

*this

Notes

L’affectation effectue une copie superficielle du pointeur de données et de la taille. Une copie superficielle est sécurisée, car aucune span mémoire n’est allouée aux éléments qu’elle contient.

Exemple

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

Types d’un pointeur et const d’un pointeur vers un span élément.

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

Exemple

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

Obtenez un itérateur inverse pointant vers le dernier élément de ce span.

constexpr reverse_iterator rbegin() const noexcept;

Valeur retournée

Itérateur pointant vers le début de l’inverse span.

Exemple

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

Types d’une référence et d’une const référence à un span élément.

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

Exemple

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

Obtenez un itérateur d’accès aléatoire qui pointe juste au-delà de la fin de l’itérateur spaninversé.

constexpr reverse_iterator rend() const noexcept;

Valeur retournée

Itérateur inverse vers l’espace réservé suivant le dernier élément de l’inverse ; autrement dit, l’espace réservé avant le premier élément de l’élément non spaninversé span.

Notes

rend est utilisé avec un inverse span comme span::end utilisé avec un span. Utilisez-la pour tester si un itérateur inverse a atteint la fin de son span.

La valeur retournée par rend ne doit pas être déréférencement.

Exemple

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

Type d’itérateur inverse pour un span.

using reverse_iterator = std::reverse_iterator<iterator>;

Exemple

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

Obtenir le nombre d’éléments dans le span.

constexpr size_t size() const noexcept;

Valeur retournée

Nombre d'éléments dans span.

Exemple

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Obtenez la taille des éléments en span octets.

constexpr size_type size_bytes() const noexcept;

Valeur retournée

Nombre d’octets que tous les éléments de l’occupation span ; c’est-à-dire sizeof(element_type) multipliés par le nombre d’éléments dans le span.

Exemple

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

Type non signé, adapté au stockage du nombre d’éléments dans un span.

using size_type = size_t;

Exemple

#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 Constructeurs.

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

Paramètres

arr
Construire un span tableau à partir d’un tableau.

count
Nombre d’éléments qui se trouveront dans le span.

first
Itérateur vers le premier élément du span.

last
Itérateur pour juste passer le dernier élément dans le span.

N
Nombre d’éléments qui se trouveront dans le span.

other
Effectuez une copie de ce span.

r
Construisez une span valeur à partir de la plage R.

Notes

Un span stockage n’est pas gratuit pour les éléments dans la span mesure où il ne possède pas le stockage des objets qu’il contient.

Constructeur	Description
`span()`	Construire un objet vide `span`. Uniquement pris en compte lors de la résolution de surcharge lorsque le paramètre `Extent` de modèle est `0` ou `dynamic_extent`.
`span(It first, size_type count)`	Construisez un `span` élément à partir des premiers `count` éléments de l’itérateur `first`. Uniquement pris en compte lors de la résolution de surcharge lorsque le paramètre `Extent` de modèle n’est pas `dynamic_extent`.
`span(It first, End last)`	Construisez un `span` élément à partir des éléments de l’itérateur `first` jusqu’à ce que la fin `last` soit atteinte. Uniquement pris en compte lors de la résolution de surcharge lorsque le paramètre `Extent` de modèle n’est pas `dynamic_extent`. `It` doit être de type `contiguous_iterator`.
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Construisez un `span` élément à partir `N` d’éléments du tableau spécifié. Uniquement pris en compte lors de la résolution de surcharge lorsque le paramètre de `Extent` modèle est `dynamic_extent` ou est égal `N`à .
`span(R&& r)`	Construire une `span` plage à partir d’une plage. Participe uniquement à la résolution de surcharge si le paramètre `Extent` de modèle n’est pas `dynamic_extent`.
`span(const span& other)`	Constructeur de copie généré par le compilateur. Une copie superficielle du pointeur de données est sécurisée, car elle `span` n’alloue pas la mémoire pour contenir les éléments.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Conversion du constructeur : construire un à partir d’un `span` autre `span`. Participe uniquement à la résolution de surcharge si le paramètre `Extent` de modèle est `dynamic_extent`, ou `N` est `dynamic_extent` ou égal `Extent`à .

Exemple

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

Obtenez un sous-volet de ce 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

Paramètres

count
Nombre d’éléments à placer dans le sous-volet. S’il count s’agit dynamic_extent (valeur par défaut), le sous-volet est extrait de offset la fin de ce span.

offset
Emplacement dans celui-ci span pour démarrer le sous-volet.

Valeur retournée

A span partir de offset là span. Contient des count éléments.

Notes

Une version de modèle de cette fonction est disponible qui vérifie le nombre au moment de la compilation, qui conserve les informations relatives au span retour d’une span étendue fixe.

Exemple

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

Type de l’élément dans le span, sans const ou volatile qualification.

using value_type = std::remove_cv_t<T>;

Exemple

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

Guides de déduction

Les repères de déduction suivants sont fournis pour 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>>>;

Voir aussi

<span>
Comment utiliser la déduction d’argument de modèle de classe

Partager via

span classe (bibliothèque standard C++)

Syntaxe

Paramètres de modèle

Membres

Notes

Spécifications

span::back

Valeur retournée

Exemple

span::begin

Valeur retournée

Exemple

span::data

Valeur retournée

Exemple

span::difference_type

Exemple

span::element_type

Notes

Exemple

span::empty

Valeur retournée

Exemple

span::end

Valeur retournée

Notes

Exemple

span::first

Paramètres

Valeur retournée

Notes

Exemple

span::front

Valeur retournée

Exemple

span::iterator

Notes

Exemple

span::last

Paramètres

Valeur retournée

Notes

Exemple

span::operator[]

Paramètres

Valeur retournée

Exemple

span::operator=

Paramètres

Valeur retournée

Notes

Exemple

span::pointer

Exemple

span::rbegin

Valeur retournée

Exemple

span::reference

Exemple

span::rend

Valeur retournée

Notes

Exemple

span::reverse_iterator

Exemple

span::size

Valeur retournée

Exemple

span::size_bytes

Valeur retournée

Exemple

span::size_type

Exemple

span::span

Paramètres

Notes

Exemple

span::subspan

Paramètres

`span` classe (bibliothèque 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`