Partager via


span classe (bibliothèque standard C++)

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 spandu .
subspan Obtenez un sous-volet n’importe où dans le span.
Opérateurs Description
span::operator= Remplacez le spanfichier .
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();
}
2

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

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

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

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

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

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

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

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.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];
}
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;
    }
}
012

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

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

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

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

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();
}
3

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)
}
12

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

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 offsetspan. 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;
}
2

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