QSpan Class
template <typename T, std::size_t E> class QSpanEin Container ohne Eigentumsbezug über zusammenhängende Daten. Mehr...
| Überschrift: | #include <QSpan> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Core) target_link_libraries(mytarget PRIVATE Qt6::Core) |
| qmake: | QT += core |
| Seit: | Qt 6.7 |
Hinweis: Alle Funktionen dieser Klasse sind reentrant.
Öffentliche Typen
| const_iterator | |
| const_pointer | |
| const_reference | |
| const_reverse_iterator | |
| difference_type | |
| element_type | |
| iterator | |
| pointer | |
| reference | |
| reverse_iterator | |
| size_type | |
| value_type |
Öffentliche Funktionen
| 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 |
Statische öffentliche Mitglieder
| const std::size_t | extent |
Zugehörige Nicht-Mitglieder
(since 6.8) auto | as_bytes(QSpan<T, E> s) |
(since 6.8) auto | as_writable_bytes(QSpan<T, E> s) |
Ausführliche Beschreibung
QSpan<T, E> ist eine Vorlagenklasse, wobei T der Elementtyp und E die Ausdehnung (Anzahl der Elemente oder std::dynamic_extent bei einer Spanne variabler Größe) ist.
Ein QSpan verweist auf einen zusammenhängenden Teil eines anderen zusammenhängenden Containers. Er fungiert als Schnittstellentyp für alle Arten von zusammenhängenden Containern, ohne dass zuvor ein eigener Container wie QList oder std::vector erstellt werden muss.
Die Daten, auf die ein QSpan verweist, können als Array (oder als array-kompatible Datenstruktur wie z. B. ` QList`, `std::vector`, ` QVarLengthArray` usw.) dargestellt werden. QSpan selbst speichert lediglich einen Zeiger auf die Daten, daher müssen Anwender sicherstellen, dass QSpan-Objekte nicht länger bestehen als die Daten, auf die sie verweisen.
Im Gegensatz zu Ansichten wie QStringView, QLatin1StringView und QUtf8StringView können die referenzierten Daten über ein QSpan-Objekt geändert werden. Um dies zu verhindern, erstellen Sie ein QSpan über ein „ const T “ (siehe 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 mit variabler und fester Größe
Ein QSpan kann eine feste oder eine variable Größe haben.
Eine Spanne mit variabler Größe wird gebildet, indem das zweite Template-Argument weggelassen wird (oder auf ` std::dynamic_extent` gesetzt wird, was jedoch nur in C++20-Builds verfügbar ist), wie im obigen Beispiel zu sehen ist.
Ein Span mit fester Größe wird gebildet, indem eine Zahl als zweites Template-Argument übergeben wird:
Wie der Name schon sagt, ist das ` size()` eines Spans mit fester Größe zur Kompilierungszeit festgelegt, während das ` size()` eines Spans mit variabler Größe erst zur Laufzeit bestimmt wird.
Ein Span mit fester Größe lässt sich nicht standardmäßig initialisieren (es sei denn, sein extent ist Null (0)). Ein Span mit variabler Größe lässt sich standardmäßig initialisieren und weist die Werte data() == nullptr und size() == 0 auf.
Ein Span mit fester Größe kann implizit in einen Span mit variabler Größe konvertiert werden. Für die umgekehrte Richtung (von variabler Länge zu fester Länge) gilt die Vorbedingung, dass die Größen beider Spans übereinstimmen müssen.
Konstante und veränderbare Spans
Anders als bei „Owning“-Containern ist die „ const “ in QSpan oberflächlich: Man kann die Daten weiterhin über einen `const QSpan` ändern (jedoch nicht über einen ` QSpan<const T>`), und ` begin()` sowie ` end()` sind für ` const` und `non-const` nicht überladen. Es gibt jedoch ` cbegin()` und ` cend()`, die `const_iterators` zurückgeben, welche eine Änderung der Daten verhindern, auch wenn ` T ` nicht `const` ist:
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_iteratorWeitere Eigenschaften
QSpan sollte als Wert übergeben werden, nicht als Referenz auf eine Konstante:
void consume(QSpan<const int> data); // OK
void consume(const QSpan<const int> &data); // works, but is non-idiomatic and less efficientQSpan<T,N> ist ein Literal-Typ, unabhängig davon, ob „ T “ ein Literal-Typ ist oder nicht.
QSpan vs. std::span
QSpan orientiert sich stark an std::span, weist jedoch einige Unterschiede auf, auf die wir hier eingehen werden. Da beide implizit ineinander konvertiert werden können, steht es Ihnen frei, in Ihrem eigenen Code den Typ zu wählen, der Ihnen am besten gefällt.
- QSpan verwendet den vorzeichenbehafteten `qsizetype` als `
size_type`, während `std::span` `size_t` verwendet. - (seit Qt 6.9) „
QSpan<const T>“ trennt Qt-Container nicht ab, „std::span“ hingegen schon. - Alle QSpan-Konstruktoren sind implizit; viele von
std::spansindexplicit. - QSpan kann aus rvalue-eigenden Containern konstruiert werden,
std::spanhingegen nicht.
Die letzten beiden sind für die Quellcode-Kompatibilität erforderlich, wenn Funktionen, die bisher „owning“-Container entgegennahmen, so umgestellt werden, dass sie stattdessen QSpan entgegennehmen – ein äußerst wichtiger Anwendungsfall in Qt. Die Verwendung von `qsizetype` dient der Konsistenz mit den übrigen Qt-Containern. Die Template-Argumente von `QSpan` verwenden weiterhin `size_t`, um unnötige Fehlerbedingungen (negative Größen) zu vermeiden.
Kompatible Iteratoren
QSpan kann aus einem Iterator und einer Größe oder aus einem Iteratorpaar erstellt werden, vorausgesetzt, die Iteratoren sind kompatibel. Letztendlich sollte dies C++20- std::contiguous_iterator und std::sentinel_for bedeuten, doch solange Qt noch C++17 unterstützt, gelten nur Rohzeiger als zusammenhängende Iteratoren.
Kompatible Bereiche
Ein `QSpan` kann auch aus einem kompatiblen Bereich erstellt werden. Ein Bereich ist kompatibel, wenn er ` compatible iterators` erfüllt.
Siehe auch QList, QStringView, QLatin1StringView und QUtf8StringView.
Dokumentation zu Mitgliedstypen
[alias] QSpan::const_iterator
Ein Alias für const T* bzw. const_pointer.
Siehe auch const_pointer, iterator, const_reverse_iterator und Const and Mutable Spans.
[alias] QSpan::const_pointer
Ein Alias für „ const T* “ bzw. „ const element_type* “.
Dieser Alias wird aus Kompatibilitätsgründen mit der STL bereitgestellt.
Siehe auch element_type, pointer, const_reference, const_iterator und Const and Mutable Spans.
[alias] QSpan::const_reference
Ein Alias für const T& bzw. const element_type&.
Dieser Alias wird aus Gründen der Kompatibilität mit der STL bereitgestellt.
Siehe auch element_type, reference, const_pointer und Const and Mutable Spans.
[alias] QSpan::const_reverse_iterator
Ein Alias für std::reverse_iterator<const_iterator>.
Siehe auch const_iterator, reverse_iterator und Const and Mutable Spans.
[alias] QSpan::difference_type
Ein Alias für „qptrdiff“. Dies differs from std::span.
Dieser Alias wird aus Gründen der Kompatibilität mit der STL bereitgestellt.
[alias] QSpan::element_type
Ein Alias für ` T`. Umfasst gegebenenfalls auch die ` const`.
Dieser Alias wird aus Kompatibilitätsgründen mit der STL bereitgestellt.
Siehe auch „ value_type “, „ pointer “ und „ Const and Mutable Spans “.
[alias] QSpan::iterator
Ein Alias für T* bzw. pointer. Umfasst gegebenenfalls auch const.
Siehe auch pointer, const_iterator, reverse_iterator und Const and Mutable Spans.
[alias] QSpan::pointer
Ein Alias für T* bzw. element_type*. Umfasst gegebenenfalls auch const.
Dieser Alias wird aus Gründen der Kompatibilität mit der STL bereitgestellt.
Siehe auch element_type, const_pointer, reference, iterator und Const and Mutable Spans.
[alias] QSpan::reference
Ein Alias für T& bzw. element_type&. Umfasst gegebenenfalls auch const.
Dieser Alias wird aus Kompatibilitätsgründen mit der STL bereitgestellt.
Siehe auch element_type, const_reference, pointer und Const and Mutable Spans.
[alias] QSpan::reverse_iterator
Ein Alias für std::reverse_iterator<iterator>. Umfasst gegebenenfalls auch const.
Siehe auch iterator, const_reverse_iterator und Const and Mutable Spans.
[alias] QSpan::size_type
Ein Alias für „qsizetype“. Dies differs from std::span.
Dieser Alias wird aus Gründen der Kompatibilität mit der STL bereitgestellt.
[alias] QSpan::value_type
Ein Alias für „ T “. Schließt gegebenenfalls „ const “ aus.
Dieser Alias wird aus Kompatibilitätsgründen mit der STL bereitgestellt.
Siehe auch element_type und Const and Mutable Spans.
Dokumentation zu den Mitgliedsfunktionen
[implicit] QSpan::QSpan()
Standardkonstruktor.
Dieser Konstruktor ist nur vorhanden, wenn „ E “ entweder Null (0) oder „ std::dynamic_extent “ ist. Mit anderen Worten: Nur Spans mit fester Größe Null oder variabler Größe lassen sich mit dem Standardkonstruktor instanziieren.
Siehe auch „ extent “ und „ 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)
Erstellt ein „ QSpan “, das auf die Daten in der angegebenen „span“ verweist: other.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn
- entweder „
N“ oder „ extent “ „std::dynamic_extent“ oder „ extent “ sind==N - und entweder
Soderconst SmitTübereinstimmen.
[constexpr] template <typename Range, QSpan<T, E>::if_compatible_range<Range> = true> QSpan::QSpan(Range &&r)
Erstellt ein QSpan, das auf die Daten im angegebenen Bereich r verweist.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn Range ein „ a compatible range “ ist.
[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)
Erstellt ein ` QSpan `, das auf die Daten im übergebenen Array ` arr` verweist.
Hinweis: ` q20::type_identity_t ` ist ein C++17-Backport von C++20s std::type_identity_t.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn
- entweder `
N` oder ` extent ` `std::dynamic_extent` sind oder andernfalls ` extent ` `==`N - und entweder
Soderconst SmitTübereinstimmen.
[constexpr] QSpan::QSpan(std::initializer_list<QSpan<T, E>::value_type> il)
Erstellt ein QSpan, das auf die Daten in der übergebenen Initialisierungsliste verweist: il.
Hinweis: Dieser Konstruktor ist nur dann „ noexcept “, wenn „ E “ „ std::dynamic_extent “ ist.
Hinweis: Wenn „ E “ nicht „ std::dynamic_extent “ ist und die Größe von „ il “ nicht „ E “ ist, ist das Verhalten undefiniert.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn „ T “ mit „ const “ qualifiziert ist.
Siehe auch „ Const and Mutable Spans “.
[constexpr] template <typename It, QSpan<T, E>::if_compatible_iterator<It> = true> QSpan::QSpan(It first, It last)
Erstellt ein QSpan, das auf die Daten verweist, die bei first beginnen und die Länge (last – first) haben.
[first, last) muss ein gültiger Bereich sein.
Einschränkungen
Nimmt nur dann an der Überlastauflösung teil, wenn It gleich a compatible iterator ist.
[constexpr] template <typename It, QSpan<T, E>::if_compatible_iterator<It> = true> QSpan::QSpan(It first, qsizetype count)
Erstellt ein QSpan, das auf die Daten verweist, die bei first beginnen und die Länge count haben.
[first, count) muss ein gültiger Bereich sein.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn It gleich a compatible iterator ist.
[constexpr] auto QSpan::back() const
Gibt eine Referenz auf das letzte Element im Bereich zurück.
Der Bereich darf nicht leer sein, andernfalls ist das Verhalten undefiniert.
Siehe auch operator[](), front(), size(), empty() und Const and Mutable Spans.
[constexpr noexcept] auto QSpan::begin() const
Gibt einen Iterator zurück, der auf den Anfang des Bereichs zeigt.
Da Iteratoren von „ QSpan “ lediglich Zeiger sind, entspricht dies dem Aufruf von „ data()“.
Siehe auch end(), cbegin(), rbegin(), crbegin(), data() und Const and Mutable Spans.
[constexpr noexcept] auto QSpan::cbegin() const
Gibt einen ` const_iterator ` zurück, der auf den Anfang des Bereichs zeigt.
Dies gibt einen schreibgeschützten Iterator zurück, auch wenn „ T “ nicht „ const “ ist:
QSpan<int> span = ~~~;
*span.begin() = 42; // OK
*span.cbegin() = 42; // ERROR: cannot assign through a const_iteratorSiehe auch „ cend()“, „ begin()“, „ crbegin()“, „ rbegin()“, „ data()“ und „ Const and Mutable Spans “.
[constexpr noexcept] auto QSpan::cend() const
Gibt einen ` const_iterator ` zurück, der auf eine Position direkt hinter dem Ende des Bereichs verweist.
Siehe auch cbegin(), end(), crend(), rend(), data(), size() und Const and Mutable Spans.
[constexpr, since 6.9] void QSpan::chop(QSpan<T, E>::size_type n)
Genau wie unter *this = chopped(,n und).
Diese Funktion ist nur unter variable-sized spans verfügbar.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch chopped().
[constexpr, since 6.9] auto QSpan::chopped(QSpan<T, E>::size_type n) const
Gibt einen „ variable-sized “-Span der Größe size() – n zurück, der auf die ersten size() – n Elemente dieses Spans verweist.
Entspricht first(size() - n).
n muss nicht-negativ sein.
Dieser Bereich muss mindestens n Elemente enthalten (E >= n und size() >= n), andernfalls ist das Verhalten undefiniert.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type) und chop().
[constexpr noexcept] auto QSpan::crbegin() const
Gibt ein „ const_reverse_iterator “ zurück, das auf den Anfang des umgekehrten Abschnitts verweist.
Siehe auch crend(), rbegin(), cbegin(), begin() und Const and Mutable Spans.
[constexpr noexcept] auto QSpan::crend() const
Gibt einen „ const_reverse_iterator “ zurück, der auf eine Position verweist, die eine Position hinter dem Ende des umgekehrten Bereichs liegt.
Siehe auch crbegin(), rend(), cend(), end() und Const and Mutable Spans.
[constexpr noexcept] auto QSpan::data() const
Gibt einen Zeiger auf den Anfang des Bereichs zurück.
Entspricht dem Aufruf von ` begin()`.
Siehe auch „ begin()“, „ front()“ und „ Const and Mutable Spans “.
Gibt zurück, ob die Span leer ist, d. h., ob size() == 0 gilt.
Diese Funktionen haben dieselbe Funktion: ` empty()` dient der STL-Kompatibilität und ` isEmpty()` der Qt-Kompatibilität.
Siehe auch ` size()` und ` size_bytes()`.
[constexpr noexcept] auto QSpan::end() const
Gibt einen Iterator zurück, der auf die Position unmittelbar nach dem Ende des Bereichs zeigt.
Da Iteratoren von „ QSpan “ lediglich Zeiger sind, entspricht dies dem Aufruf von „ data() + size() “.
Siehe auch „ begin()“, „ cend()“, „ rend()“, „ crend()“, „ data()“, „ size()“ und „ Const and Mutable Spans “.
[constexpr noexcept(...)] template <std::size_t Count> auto QSpan::first() const
Gibt eine „ fixed-sized “-Span der Größe „ Count “ zurück, die auf die ersten „ Count “-Elemente von „ *this “ verweist.
Der Bereich muss mindestens Count Elemente enthalten (E >= Count und size() >= Count), andernfalls ist das Verhalten undefiniert.
Hinweis: Diese Funktion ist `noexcept`, wenn ` subspan_always_succeeds_v<Count> ` ein ` true` ist.
Siehe auch „ first“ (QSpan<T,E>::size_type), „ last “ () und „ subspan “ ().
[constexpr] auto QSpan::first(QSpan<T, E>::size_type n) const
Gibt eine „ variable-sized “-Spanne der Größe „ n “ zurück, die auf die ersten „ n “-Elemente von „ *this “ verweist.
n muss nicht-negativ sein.
Der Bereich muss mindestens n Elemente enthalten (E >= n und size() >= n), andernfalls ist das Verhalten undefiniert.
Siehe auch 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() und chopped().
[constexpr] auto QSpan::front() const
Gibt eine Referenz auf das erste Element im Span zurück.
Der Bereich darf nicht leer sein, andernfalls ist das Verhalten undefiniert.
Siehe auch operator[](), back(), size(), empty() und Const and Mutable Spans.
[constexpr noexcept(...)] template <std::size_t Count> auto QSpan::last() const
Gibt eine „ fixed-sized “-Span der Größe „ Count “ zurück, die auf die letzten „ Count “-Elemente von „ *this “ verweist.
Der Bereich muss mindestens Count Elemente enthalten (E >= Count und size() >= Count), andernfalls ist das Verhalten undefiniert.
Hinweis: Diese Funktion ist „noexcept“, wenn subspan_always_succeeds_v<Count> gleich true ist.
Siehe auch „ last“ (QSpan<T,E>::size_type), „ first “ () und „ subspan “ ().
[constexpr] auto QSpan::last(QSpan<T, E>::size_type n) const
Gibt eine „ variable-sized “-Spanne der Größe „ n “ zurück, die auf die letzten „ n “-Elemente von „ *this “ verweist.
n muss nicht-negativ sein.
Der Bereich muss mindestens n Elemente enthalten (E >= n und size() >= n), andernfalls ist das Verhalten undefiniert.
Siehe auch 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() und chopped().
[constexpr noexcept] auto QSpan::rbegin() const
Gibt ein ` reverse_iterator ` zurück, das auf den Anfang des umgekehrten Bereichs verweist.
Siehe auch rend(), crbegin(), begin(), cbegin() und Const and Mutable Spans.
[constexpr noexcept] auto QSpan::rend() const
Gibt einen ` reverse_iterator ` zurück, der auf die Position unmittelbar hinter dem Ende des umgekehrten Bereichs zeigt.
Siehe auch rbegin(), crend(), end(), cend() und Const and Mutable Spans.
[constexpr noexcept] auto QSpan::size() const
Gibt die Größe des Spans zurück, d. h. die Anzahl der Elemente, auf die er verweist.
Siehe auch size_bytes(), empty() und isEmpty().
[constexpr noexcept] auto QSpan::size_bytes() const
Gibt die Größe des Spans in Bytes zurück, d. h. die Anzahl der Elemente multipliziert mit sizeof(T).
Siehe auch size(), empty() und isEmpty().
[constexpr, since 6.9] void QSpan::slice(QSpan<T, E>::size_type pos)
Genau wie unter *this = sliced(,pos und).
Diese Funktion ist nur unter variable-sized spans verfügbar.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch sliced().
[constexpr, since 6.9] void QSpan::slice(QSpan<T, E>::size_type pos, QSpan<T, E>::size_type n)
Genau wie unter *this = sliced(,pos,,,n und).
Diese Funktion ist nur unter variable-sized spans verfügbar.
Diese Funktion wurde in Qt 6.9 eingeführt.
Siehe auch sliced().
[constexpr] auto QSpan::sliced(QSpan<T, E>::size_type pos) const
[constexpr] auto QSpan::subspan(QSpan<T, E>::size_type pos) const
Gibt eine „ variable-sized “-Span der Größe „ size() - pos “ zurück, die auf den verbleibenden Teil dieser Span verweist, nachdem die ersten „ pos “-Elemente entfernt wurden.
pos muss nicht-negativ sein.
Dieser Bereich muss mindestens pos Elemente enthalten (E >= pos und size() >= pos), andernfalls ist das Verhalten undefiniert.
Diese Funktionen bewirken dasselbe: ` subspan()` dient der STL-Kompatibilität und ` sliced()` der Qt-Kompatibilität.
Siehe auch subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type), chopped() und 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
Gibt einen Bereich vom Typ „ variable-sized “ der Größe „ n “ zurück, der auf die Elemente „ n “ dieses Bereichs verweist, beginnend bei „ pos “.
Sowohl pos als auch n müssen nicht-negativ sein.
Dieser Bereich muss mindestens pos + n Elemente enthalten (E >= pos + n und size() >= pos + n), andernfalls ist das Verhalten undefiniert.
Diese Funktionen haben denselben Zweck: ` subspan()` dient der STL-Kompatibilität und ` sliced()` der Qt-Kompatibilität.
Siehe auch subspan(), first(QSpan<T,E>::size_type), last(QSpan<T,E>::size_type), chopped() und slice().
[constexpr noexcept(...)] template <std::size_t Offset, std::size_t Count> auto QSpan::subspan() const
Gibt einen Span der Größe „ Count “ zurück, der auf die Elemente „ Count “ dieses Spans verweist, beginnend bei „ Offset “.
Ist *this ein Span variabler Größe, ist der Rückgabetyp ein Span variabler Größe, andernfalls ist es ein Span fester Größe.
Dieser Bereich muss mindestens Offset + Count Elemente enthalten (E >= Offset + Count und size() >= Offset + Count), andernfalls ist das Verhalten undefiniert.
Hinweis: Diese Funktion ist „noexcept“, wenn subspan_always_succeeds_v<Offset + Count> gleich true ist.
Siehe auch subspan(QSpan<T,E>::size_type, QSpan<T,E>::size_type), first(), last() und Variable-Size and Fixed-Size Spans.
[constexpr noexcept(...)] template <std::size_t Offset> auto QSpan::subspan() const
Gibt einen Span der Größe „ E - Offset “ zurück, der auf den verbleibenden Teil dieses Spans verweist, nachdem die ersten „ Offset “ Elemente entfernt wurden.
Ist *this ein Span variabler Größe, ist der Rückgabetyp ein Span variabler Größe, andernfalls ein Span fester Größe.
Dieser Bereich muss mindestens Offset Elemente enthalten (E >= Offset und size() >= Offset), andernfalls ist das Verhalten undefiniert.
Hinweis: Diese Funktion ist „noexcept“, wenn subspan_always_succeeds_v<Offset> gleich true ist.
Siehe auch „ subspan“ (QSpan<T,E>::size_type), „ subspan “ (), „ first “ (), „ last “ () und „ 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)
Diese speziellen Mitgliedsfunktionen sind implizit definiert.
Hinweis: Verschiebungen entsprechen Kopien. Nur data() und size() werden von span nach span kopiert, nicht jedoch die referenzierten Daten.
[constexpr] QSpan<T, E>::reference QSpan::operator[](QSpan<T, E>::size_type idx) const
Gibt eine Referenz auf das Element am Index „ idx “ innerhalb des „span“-Elements zurück.
Der Index muss im zulässigen Bereich liegen, d. h. idx >= 0 und idx < size(), andernfalls ist das Verhalten undefiniert.
Siehe auch front(), back(), size(), empty() und Const and Mutable Spans.
Dokumentation zu Member-Variablen
const std::size_t QSpan::extent
Das zweite Template-Argument von ` QSpan<T, E>`, d. h. ` E`. Dies entspricht ` std::dynamic_extent ` für ` variable-sized spans`.
Hinweis: Während alle anderen Größen und Indizes in ` QSpan ` den Typ `qsizetype` verwenden, ist diese Variable, genau wie ` E`, tatsächlich vom Typ ` size_t`, um die Kompatibilität mit ` std::span ` und ` std::dynamic_extent` zu gewährleisten.
Siehe auch „ size()“.
Verwandte Nicht-Mitglieder
[noexcept, since 6.8] auto as_bytes(QSpan<T, E> s)
Gibt „ s “ als „ QSpan<const std::byte, E'> “ zurück, dessen „ size()“-Wert gleich „ s.size_bytes() “ ist.
Ist E ein „ std::dynamic_extent “, so ist auch E' ein „ “. Andernfalls gilt E' = E * sizeof(T).
Hinweis: ` q20::dynamic_extent ` ist ein C++17-Backport von C++20s std::dynamic_extent.
Diese Funktion wurde in Qt 6.8 eingeführt.
Siehe auch as_writable_bytes(), size_bytes() und Const and Mutable Spans.
[noexcept, since 6.8] auto as_writable_bytes(QSpan<T, E> s)
Gibt „ s “ als „ QSpan<std::byte, E'> “ zurück, dessen „ size()“-Wert gleich „ s.size_bytes() “ ist.
Ist E ein „ std::dynamic_extent “, dann ist auch E' ein „ “. Andernfalls gilt: E' = E * sizeof(T).
Hinweis: ` q20::dynamic_extent ` ist ein C++17-Backport von C++20s std::dynamic_extent.
Einschränkungen
Nimmt nur dann an der Überladungsauflösung teil, wenn !std::is_const_v<T> gilt.
Diese Funktion wurde in Qt 6.8 eingeführt.
Siehe auch as_bytes(), size_bytes() und 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.