QSpan Class
template <typename T, std::size_t E> class QSpanUn conteneur sans propriété sur des données contiguës. En savoir plus...
| En-tête : | #include <QSpan> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake : | QT += core |
| Depuis : | Qt 6.7 |
Remarque : toutes les fonctions de cette classe sont réentrantes.
Types publics
| const_iterator | |
| const_pointer | |
| const_reference | |
| const_reverse_iterator | |
| difference_type | |
| element_type | |
| iterator | |
| pointer | |
| reference | |
| reverse_iterator | |
| size_type | |
| value_type |
Fonctions publiques
| QSpan() | |
| QSpan(QSpan<S, N> other) | |
| QSpan(Range &&r) | |
| QSpan(const std::array<S, N> &arr) | |
| QSpan(q20::type_identity_t<T> (&arr)[N]) | |
| QSpan(std::array<S, N> &arr) | |
| QSpan(std::initializer_list<QSpan<T, E>::value_type> il) | |
| QSpan(std::span<S, N> other) | |
| QSpan(It first, It last) | |
| QSpan(It first, qsizetype count) | |
| QSpan(const QSpan<T, E> &other) | |
| QSpan(QSpan<T, E> &&other) | |
| ~QSpan() | |
| auto | back() const |
| auto | begin() const |
| auto | cbegin() const |
| auto | cend() const |
(since 6.9) void | chop(QSpan<T, E>::size_type n) |
(since 6.9) auto | chopped(QSpan<T, E>::size_type n) const |
| auto | crbegin() const |
| auto | crend() const |
| auto | data() const |
| auto | empty() const |
| auto | end() const |
| auto | first() const |
| auto | first(QSpan<T, E>::size_type n) const |
| auto | front() const |
| auto | isEmpty() const |
| auto | last() const |
| auto | last(QSpan<T, E>::size_type n) const |
| auto | rbegin() const |
| auto | rend() const |
| auto | size() const |
| auto | size_bytes() const |
(since 6.9) void | slice(QSpan<T, E>::size_type pos) |
(since 6.9) void | slice(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n) |
| auto | sliced(QSpan<T, E>::size_type pos) const |
| auto | sliced(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n) const |
| auto | subspan() const |
| auto | subspan() const |
| auto | subspan(QSpan<T, E>::size_type pos) const |
| auto | subspan(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n) const |
| QSpan<T, E> & | operator=(QSpan<T, E> &&other) |
| QSpan<T, E> & | operator=(const QSpan<T, E> &other) |
| QSpan<T, E>::reference | operator[](QSpan<T, E>::size_type idx) const |
Membres publics statiques
| const std::size_t | extent |
Éléments non membres associés
(since 6.8) auto | as_bytes(QSpan<T, E> s) |
(since 6.8) auto | as_writable_bytes(QSpan<T, E> s) |
Description détaillée
QSpan<T, E> est une classe de modèle où T est le type d'élément et E est l'étendue (nombre d'éléments, ou std::dynamic_extent pour un intervalle de taille variable).
Un QSpan fait référence à une partie contiguë d’un autre conteneur contigu. Il sert de type d’interface pour tous les types de conteneurs contigus, sans qu’il soit nécessaire de créer au préalable un conteneur propriétaire tel que QList ou std::vector.
Les données référencées par un QSpan peuvent être représentées sous la forme d’un tableau (ou d’une structure de données compatible avec les tableaux, telle que QList, std::vector, QVarLengthArray, etc.). QSpan lui-même ne stocke qu’un pointeur vers les données ; les utilisateurs doivent donc s’assurer que les objets QSpan ne survivent pas aux données qu’ils référencent.
Contrairement aux vues telles que QStringView, QLatin1StringView et QUtf8StringView, les données référencées peuvent être modifiées via un objet QSpan. Pour éviter cela, créez un QSpan sur un const T (voir Const and Mutable Spans) :
int numbers[] = {0, 1, 2};
QSpan<int> span = numbers;
span[0] = 42;
// numbers == {42, 1, 2};
QSpan<const int> cspan = numbers;
cspan[0] = 0; // ERROR: cspan[0] is read-onlySpans à taille variable et à taille fixe
Un QSpan peut être de taille fixe ou variable.
Une portée à taille variable est créée en omettant le deuxième argument du modèle (ou en le définissant sur ` std::dynamic_extent`, ce qui n'est toutefois disponible que dans les versions C++20), comme le montre l'exemple ci-dessus.
Un span de taille fixe est créé en passant un nombre comme deuxième argument de modèle :
Comme son nom l'indique, l'size() d'un span de taille fixe est déterminée à la compilation, tandis que l'size() d'un span de taille variable n'est déterminée qu'à l'exécution.
Un span de taille fixe ne peut pas être construit par défaut (à moins que son extent ne soit égal à zéro (0)). Un span de taille variable peut être construit par défaut et aura data() == nullptr et size() == 0.
Un span de taille fixe peut être implicitement converti en un span de taille variable. Dans le sens inverse (de taille variable vers taille fixe), la condition préalable est que les tailles des deux spans doivent correspondre.
Spans constants et modifiables
Contrairement aux conteneurs propriétaires, l’ const e est superficielle dans QSpan : vous pouvez toujours modifier les données via un QSpan const (mais pas via un QSpan<const T>), et les méthodes begin() et end() ne sont pas surchargées sur les const/non-const. Il existe toutefois des méthodes cbegin() et cend() qui renvoient des const_iterators empêchant la modification des données, même si T n’est pas const :
int numbers[] = {0, 1, 2};
const QSpan<int> span = numbers;
span.front() = 42; // OK, numbers[0] == 42 now
*span.begin() = 31; // OK, numbers[0] == 31 now
*span.cbegin() = -1; // ERROR: cannot assign through a const_iteratorAutres propriétés
QSpan doit être passé par valeur, et non par référence à une constante :
void consume(QSpan<const int> data); // OK
void consume(const QSpan<const int> &data); // works, but is non-idiomatic and less efficientQSpan<T,N> est un type littéral, que T soit ou non un type littéral.
QSpan vs std::span
QSpan s'inspire étroitement de std::span, mais présente quelques différences que nous allons aborder ici. Étant donné qu'ils se convertissent implicitement l'un en l'autre, vous êtes libre de choisir celui qui vous convient le mieux dans votre code.
- QSpan utilise le type qsizetype signé comme
size_type, tandis questd::spanutilisesize_t. - (depuis Qt 6.9) `
QSpan<const T>` ne détache pas les conteneurs Qt, contrairement à `std::span`. - Tous les constructeurs de QSpan sont implicites ; beaucoup de ceux de
std::spansontexplicit. - QSpan peut être construit à partir de conteneurs possédant des rvalues, ce qui n’est pas le cas d’
std::span.
Ces deux dernières caractéristiques sont nécessaires pour assurer la compatibilité des sources lorsque des fonctions qui prenaient des conteneurs en propriété sont converties pour prendre des QSpan à la place, ce qui constitue un cas d’utilisation d’une importance capitale dans Qt. L’utilisation de `qsizetype` vise à assurer la cohérence avec le reste des conteneurs Qt. Les arguments du modèle QSpan utilisent toujours `size_t` afin d’éviter d’introduire des conditions d’erreur inutiles (tailles négatives).
Itérateurs compatibles
Un `QSpan` peut être construit à partir d’un itérateur et d’une taille, ou à partir d’une paire d’itérateurs, à condition que ces itérateurs soient compatibles. À terme, cela devrait correspondre aux itérateurs contigus de C++20 ( std::contiguous_iterator ) et aux itérateurs non contigus ( std::sentinel_for), mais tant que Qt prendra encore en charge C++17, seuls les pointeurs bruts seront considérés comme des itérateurs contigus.
Plages compatibles
Un `QSpan` peut également être construit à partir d’une plage compatible. Une plage est compatible si elle répond à la définition suivante : compatible iterators.
Voir également QList, QStringView, QLatin1StringView et QUtf8StringView.
Documentation sur les types de membres
[alias] QSpan::const_iterator
Un alias pour const T* et const_pointer, respectivement.
Voir également const_pointer, iterator, const_reverse_iterator et Const and Mutable Spans.
[alias] QSpan::const_pointer
Un alias pour const T* et const element_type*, respectivement.
Cet alias est fourni à des fins de compatibilité avec la STL.
Voir également element_type, pointer, const_reference, const_iterator et Const and Mutable Spans.
[alias] QSpan::const_reference
Un alias pour const T& et const element_type&, respectivement.
Cet alias est fourni à des fins de compatibilité avec la STL.
Voir également element_type, reference, const_pointer et Const and Mutable Spans.
[alias] QSpan::const_reverse_iterator
Un alias pour std::reverse_iterator<const_iterator>.
Voir également const_iterator, reverse_iterator et Const and Mutable Spans.
[alias] QSpan::difference_type
Un alias pour qptrdiff. Ceci differs from std::span.
Cet alias est fourni à des fins de compatibilité avec la STL.
[alias] QSpan::element_type
Un alias pour T. Inclut l'const, le cas échéant.
Cet alias est fourni à des fins de compatibilité avec la STL.
Voir également value_type, pointer et Const and Mutable Spans.
[alias] QSpan::iterator
Un alias pour T* et pointer, respectivement. Comprend l'const, le cas échéant.
Voir également pointer, const_iterator, reverse_iterator et Const and Mutable Spans.
[alias] QSpan::pointer
Un alias pour T* et element_type*, respectivement. Inclut l'const, le cas échéant.
Cet alias est fourni à des fins de compatibilité avec la STL.
Voir également element_type, const_pointer, reference, iterator et Const and Mutable Spans.
[alias] QSpan::reference
Un alias pour T& et element_type&, respectivement. Inclut l'const, le cas échéant.
Cet alias est fourni à des fins de compatibilité avec la STL.
Voir également element_type, const_reference, pointer et Const and Mutable Spans.
[alias] QSpan::reverse_iterator
Un alias pour std::reverse_iterator<iterator>. Comprend l'const, le cas échéant.
Voir également iterator, const_reverse_iterator et Const and Mutable Spans.
[alias] QSpan::size_type
Un alias pour « qsizetype ». Ceci differs from std::span.
Cet alias est fourni à des fins de compatibilité avec la STL.
[alias] QSpan::value_type
Un alias pour ` T`. Exclut ` const`, le cas échéant.
Cet alias est fourni à des fins de compatibilité avec la STL.
Voir également element_type et Const and Mutable Spans.
Documentation des fonctions membres
[implicit] QSpan::QSpan()
Constructeur par défaut.
Ce constructeur n'est présent que si « E » vaut soit zéro (0), soit « std::dynamic_extent ». En d'autres termes : seules les portées de taille fixe nulle ou de taille variable peuvent être construites par défaut.
Voir également extent et Variable-Size and Fixed-Size Spans.
[constexpr noexcept] template <
typename S,
size_t N,
QSpan<T, E>::if_qualification_conversion<S> = true
>
QSpan::QSpan(QSpan<S, N> other)
[constexpr noexcept] template <
typename S,
size_t N,
QSpan<T, E>::if_qualification_conversion<S> = true
>
QSpan::QSpan(std::span<S, N> other)
Crée un objet ` QSpan ` faisant référence aux données contenues dans la balise `span` fournie other.
Contraintes
Ne participe à la résolution des surcharges que si
- soit
N, soit extent, sontstd::dynamic_extentou extent==N - et que soit
S, soitconst S, est identique àT.
[constexpr] template <typename Range, QSpan<T, E>::if_compatible_range<Range> = true> QSpan::QSpan(Range &&r)
Crée un objet `QSpan` faisant référence aux données de la plage fournie r.
Contraintes
Ne participe à la résolution des surcharges que si ` Range ` est de type ` a compatible range`.
[constexpr noexcept] template <
typename S,
size_t N,
QSpan<T, E>::if_qualification_conversion<S> = true
>
QSpan::QSpan(const std::array<S, N> &arr)
[constexpr noexcept] template <size_t N> QSpan::QSpan(q20::type_identity_t<T> (&arr)[N])
[constexpr noexcept] template <
typename S,
size_t N,
QSpan<T, E>::if_qualification_conversion<S> = true
>
QSpan::QSpan(std::array<S, N> &arr)
Crée un objet ` QSpan ` faisant référence aux données du tableau fourni ` arr`.
Remarque : ` q20::type_identity_t ` est une adaptation en C++17 de la fonctionnalité de C++20 std::type_identity_t.
Contraintes
Ne participe à la résolution des surcharges que si
- soit
N, soit extent est de typestd::dynamic_extentou, dans le cas contraire, extent==N - et que soit
S, soitconst S, soit identique àT.
[constexpr] QSpan::QSpan(std::initializer_list<QSpan<T, E>::value_type> il)
Crée un objet `QSpan` faisant référence aux données de la liste d'initialisation fournie il.
Remarque : ce constructeur n'est noexcept que si E est std::dynamic_extent.
Remarque : si E n’est pas std::dynamic_extent et que la taille de il n’est pas E, le comportement est indéfini.
Contraintes
Ne participe à la résolution des surcharges que si T est qualifié par const.
Voir également Const and Mutable Spans.
[constexpr] template <typename It, QSpan<T, E>::if_compatible_iterator<It> = true> QSpan::QSpan(It first, It last)
Crée un objet QSpan faisant référence aux données commençant à l'adresse first et dont la longueur est comprise entre (last et first).
[first, last) doit être un intervalle valide.
Contraintes
Ne participe à la résolution des surcharges que si It est égal à a compatible iterator.
[constexpr] template <typename It, QSpan<T, E>::if_compatible_iterator<It> = true> QSpan::QSpan(It first, qsizetype count)
Crée un objet QSpan faisant référence aux données commençant à l'adresse first et d'une longueur de count.
[first, count) doit être un intervalle valide.
Contraintes
Ne participe à la résolution des surcharges que si It est égal à a compatible iterator.
[constexpr] auto QSpan::back() const
Renvoie une référence au dernier élément de la plage.
La balise span ne doit pas être vide, sinon le comportement est indéfini.
Voir également operator[](), front(), size(), empty() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::begin() const
Renvoie un itérateur pointant vers le début de la plage.
Les itérateurs de QSpan n'étant que des pointeurs, cela revient à appeler data().
Voir également end(), cbegin(), rbegin(), crbegin(), data() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::cbegin() const
Renvoie un objet ` const_iterator ` pointant vers le début de la plage.
Cela renverra un itérateur en lecture seule même si T n'est pas de type const:
QSpan<int> span = ~~~;
*span.begin() = 42; // OK
*span.cbegin() = 42; // ERROR: cannot assign through a const_iteratorVoir également cend(), begin(), crbegin(), rbegin(), data() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::cend() const
Renvoie un objet ` const_iterator ` pointant sur l'élément situé juste après la fin de la balise `span`.
Voir également cbegin(), end(), crend(), rend(), data(), size() et Const and Mutable Spans.
[constexpr, since 6.9] void QSpan::chop(QSpan<T, E>::size_type n)
Comme sur *this = chopped(,n et).
Cette fonction n'est disponible que sur variable-sized spans.
Cette fonction a été introduite dans Qt 6.9.
Voir également chopped().
[constexpr, since 6.9] auto QSpan::chopped(QSpan<T, E>::size_type n) const
Renvoie une plage « variable-sized » de taille size() - n faisant référence aux premiers éléments size() - n de cette plage.
Identique à first(size() - n).
n doit être non négatif.
Cette balise « span » doit contenir au moins n éléments (E >= n et size() >= n), sinon le comportement est indéfini.
Cette fonction a été introduite dans Qt 6.9.
Voir également subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type) et chop().
[constexpr noexcept] auto QSpan::crbegin() const
Renvoie un objet ` const_reverse_iterator ` pointant vers le début de la plage inversée.
Voir également crend(), rbegin(), cbegin(), begin() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::crend() const
Renvoie un objet ` const_reverse_iterator ` pointant sur l'élément situé juste après la fin de la plage inversée.
Voir également crbegin(), rend(), cend(), end() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::data() const
Renvoie un pointeur vers le début de la plage.
Cela revient à appeler la fonction begin().
Voir également begin(), front() et Const and Mutable Spans.
Renvoie si la plage est vide, c'est-à-dire si size() == 0.
Ces fonctions ont le même effet : ` empty()` est fournie pour assurer la compatibilité avec la STL et ` isEmpty()` est fournie pour assurer la compatibilité avec Qt.
Voir également ` size()` et ` size_bytes()`.
[constexpr noexcept] auto QSpan::end() const
Renvoie un itérateur pointant sur l'élément suivant la fin de la plage.
Les itérateurs de QSpan n'étant que des pointeurs, cela revient à appeler data() + size().
Voir également begin(), cend(), rend(), crend(), data(), size() et Const and Mutable Spans.
[constexpr noexcept(...)] template <std::size_t Count> auto QSpan::first() const
Renvoie une séquence de type « fixed-sized » de taille « Count » faisant référence aux x premiers éléments de type « Count » de « *this ».
La plage doit contenir au moins Count éléments (E >= Count et size() >= Count), sinon le comportement est indéfini.
Remarque : cette fonction est « noexcept » lorsque subspan_always_succeeds_v<Count> est true.
Voir également first(QSpan<T,E>::size_type), last() et subspan().
[constexpr] auto QSpan::first(QSpan<T, E>::size_type n) const
Renvoie une plage de type « variable-sized » de taille « n » faisant référence aux premiers « n » éléments de « *this ».
n doit être non négatif.
Le span doit contenir au moins n éléments (E >= n et size() >= n), sinon le comportement est indéfini.
Voir également first<N>(), last(QSpan<T,E>::size_type), subspan(QSpan<T,E>::size_type), subspan(QSpan<T,E>::size_type, QSpan<T,E>::size_type), sliced() et chopped().
[constexpr] auto QSpan::front() const
Renvoie une référence au premier élément de la balise `span`.
La balise span ne doit pas être vide, sinon le comportement est indéfini.
Voir également operator[](), back(), size(), empty() et Const and Mutable Spans.
[constexpr noexcept(...)] template <std::size_t Count> auto QSpan::last() const
Renvoie une portée « fixed-sized » de taille « Count » faisant référence aux derniers éléments « Count » de « *this ».
La plage doit contenir au moins Count éléments (E >= Count et size() >= Count), sinon le comportement est indéfini.
Remarque : cette fonction est « noexcept » lorsque subspan_always_succeeds_v<Count> est true.
Voir également last(QSpan<T,E>::size_type), first() et subspan().
[constexpr] auto QSpan::last(QSpan<T, E>::size_type n) const
Renvoie une plage de type « variable-sized » de taille « n » faisant référence aux derniers éléments « n » de « *this ».
n doit être un nombre non négatif.
Le span doit contenir au moins n éléments (E >= n et size() >= n), sinon le comportement est indéfini.
Voir également last(), first(QSpan<T,E>::size_type), subspan(QSpan<T,E>::size_type), subspan(QSpan<T,E>::size_type, QSpan<T,E>::size_type), sliced() et chopped().
[constexpr noexcept] auto QSpan::rbegin() const
Renvoie un objet ` reverse_iterator ` pointant vers le début de la plage inversée.
Voir également rend(), crbegin(), begin(), cbegin() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::rend() const
Renvoie un objet ` reverse_iterator ` pointant sur un élément situé juste après la fin de la plage inversée.
Voir également rbegin(), crend(), end(), cend() et Const and Mutable Spans.
[constexpr noexcept] auto QSpan::size() const
Renvoie la taille de la balise span, c'est-à-dire le nombre d'éléments auxquels elle fait référence.
Voir également size_bytes(), empty() et isEmpty().
[constexpr noexcept] auto QSpan::size_bytes() const
Renvoie la taille de la plage en octets, c'est-à-dire le nombre d'éléments multiplié par sizeof(T).
Voir également size(), empty() et isEmpty().
[constexpr, since 6.9] void QSpan::slice(QSpan<T, E>::size_type pos)
Comme sur *this = sliced(,pos et).
Cette fonction n’est disponible que sur variable-sized spans.
Cette fonction a été introduite dans Qt 6.9.
Voir également sliced().
[constexpr, since 6.9] void QSpan::slice(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n)
Comme sur *this = sliced(,pos,,,n,).
Cette fonction n'est disponible que sur variable-sized spans.
Cette fonction a été introduite dans Qt 6.9.
Voir également sliced().
[constexpr] auto QSpan::sliced(QSpan<T, E>::size_type pos) const
[constexpr] auto QSpan::subspan(QSpan<T, E>::size_type pos) const
Renvoie un intervalle de type « variable-sized » de taille « size() - pos » faisant référence au reste de cet intervalle après avoir supprimé les premiers éléments « pos ».
pos doit être non négatif.
Ce span doit contenir au moins pos éléments (E >= pos et size() >= pos), sinon le comportement est indéfini.
Ces fonctions ont le même effet : ` subspan()` est fournie pour assurer la compatibilité avec la STL et ` sliced()` est fournie pour assurer la compatibilité avec Qt.
Voir également subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type), chopped() et slice().
[constexpr] auto QSpan::sliced(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n) const
[constexpr] auto QSpan::subspan(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n) const
Renvoie une plage de type « variable-sized » de taille « n » faisant référence aux éléments « n » de cette plage, en commençant par « pos ».
pos et n doivent tous deux être non négatifs.
Cette plage doit contenir au moins pos + n éléments (E >= pos + n et size() >= pos + n), sinon le comportement est indéfini.
Ces fonctions ont le même effet : ` subspan()` est fournie pour la compatibilité avec la STL et ` sliced()` est fournie pour la compatibilité avec Qt.
Voir également subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type), chopped() et slice().
[constexpr noexcept(...)] template <std::size_t Offset, std::size_t Count> auto QSpan::subspan() const
Renvoie un « span » de taille « Count » faisant référence aux éléments « Count » de ce « span », à partir de « Offset ».
Si *this est un intervalle de taille variable, le type de retour est un intervalle de taille variable ; sinon, il s'agit d'un intervalle de taille fixe.
Ce span doit contenir au moins Offset + Count éléments (E >= Offset + Count et size() >= Offset + Count), sinon le comportement est indéfini.
Remarque : cette fonction est « noexcept » lorsque subspan_always_succeeds_v<Offset + Count> est true.
Voir également subspan(QSpan<T,E>::size_type, QSpan<T,E>::size_type), first(), last() et Variable-Size and Fixed-Size Spans.
[constexpr noexcept(...)] template <std::size_t Offset> auto QSpan::subspan() const
Renvoie un span de taille E - Offset faisant référence au reste de ce span après avoir supprimé les premiers éléments Offset.
Si *this est un span de taille variable, le type de retour est un span de taille variable ; sinon, il s’agit d’un span de taille fixe.
Ce span doit contenir au moins Offset éléments (E >= Offset et size() >= Offset), sinon le comportement est indéfini.
Remarque : cette fonction est « noexcept » lorsque subspan_always_succeeds_v<Offset> est true.
Voir également subspan(QSpan<T,E>::size_type), subspan(), first(), last() et Variable-Size and Fixed-Size Spans.
[implicit] QSpan<T, E> &QSpan::operator=(QSpan<T, E> &&other)
[implicit] QSpan::~QSpan()
[implicit] QSpan<T, E> &QSpan::operator=(const QSpan<T, E> &other)
[implicit] QSpan::QSpan(QSpan<T, E> &&other)
[implicit] QSpan::QSpan(const QSpan<T, E> &other)
Ces fonctions spéciales des membres sont définies implicitement.
Remarque : les déplacements sont équivalents à des copies. Seules les fonctions data() et size() sont copiées d'un span à l'autre, et non les données référencées.
[constexpr] QSpan<T, E>::reference QSpan::operator[](QSpan<T, E>::size_type idx) const
Renvoie une référence à l'élément situé à l'index idx dans la balise `span`.
L'index doit être compris dans l'intervalle, c'est-à-dire que idx >= 0 et idx < size(), sinon le comportement est indéfini.
Voir également front(), back(), size(), empty() et Const and Mutable Spans.
Documentation sur les variables membres
const std::size_t QSpan::extent
Le deuxième argument de modèle de QSpan<T, E>, c'est-à-dire E. Il s'agit de std::dynamic_extent pour variable-sized spans.
Remarque : alors que toutes les autres tailles et tous les autres index dans ` QSpan ` utilisent `qsizetype`, cette variable, tout comme ` E`, est en réalité de type ` size_t`, pour des raisons de compatibilité avec ` std::span ` et ` std::dynamic_extent`.
Voir également la fonction size().
Éléments non membres associés
[noexcept, since 6.8] auto as_bytes(QSpan<T, E> s)
Renvoie « s » sous la forme d’un objet de type « QSpan<const std::byte, E'> » dont la méthode « size() » renvoie « s.size_bytes() ».
Si ` E ` est de type ` std::dynamic_extent `, alors ` E'` l'est également. Sinon, ` E' = E * sizeof(T)`.
Remarque : q20::dynamic_extent est un portage vers C++17 de la fonctionnalité de C++20 std::dynamic_extent.
Cette fonction a été introduite dans Qt 6.8.
Voir également as_writable_bytes(), size_bytes() et Const and Mutable Spans.
[noexcept, since 6.8] auto as_writable_bytes(QSpan<T, E> s)
Renvoie s sous la forme d'un QSpan<std::byte, E'> dont la méthode size() est égale à s.size_bytes().
Si E est un std::dynamic_extent, alors E' l'est également. Sinon, E' = E * sizeof(T).
Remarque : q20::dynamic_extent est un portage en C++17 de la fonctionnalité de C++20 std::dynamic_extent.
Contraintes
Ne participe à la résolution des surcharges que si !std::is_const_v<T>.
Cette fonction a été introduite dans Qt 6.8.
Voir également as_bytes(), size_bytes() et Const and Mutable Spans.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.