`span` Klasse (C++-Standardbibliothek)

Stellt eine einfache Ansicht über eine zusammenhängende Abfolge von Objekten bereit. A span bietet eine sichere Möglichkeit zum Durchlaufen und Indizieren von Objekten, die im Arbeitsspeicher zurück-zu-hinten angeordnet sind. Beispielsweise Objekte, die in einem integrierten Array gespeichert sind, std::arrayoder std::vector.

Wenn Sie in der Regel mithilfe eines Zeigers und eines Indexes auf eine Sequenz von Back-to-Back-Objekten zugreifen, ist eine span sicherere, einfache Alternative.

Die Größe einer span kann zur Kompilierungszeit festgelegt werden, indem sie als Vorlagenargument oder zur Laufzeit durch Angabe angegeben dynamic_extentwird.

Syntax

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

Vorlagenparameter

T
Der Typ der Elemente im span.

Extent
Die Anzahl der Elemente, die span zur Kompilierungszeit angegeben sind. Andernfalls std::dynamic_extent wird die Anzahl der Elemente zur Laufzeit angegeben.

Abzugsleitfaden

Member

Typdefinitionen	Beschreibung
`const_pointer`	Der Typ eines Zeigers auf ein `const` Element.
`const_reference`	Der Typ eines Verweises auf ein `const` Element.
`difference_type`	Der Typ eines Abstands mit Vorzeichen zwischen zwei Elementen.
`element_type`	Der Typ eines `span` Elements.
`iterator`	Der Typ eines Iterators für ein `span`.
`pointer`	Der Typ eines Zeigers auf ein Element.
`reference`	Der Typ eines Verweises auf ein Element.
`reverse_iterator`	Der Typ eines Umgekehrten Iterators für ein `span`.
`size_type`	Der Typ für das Ergebnis des nicht signierten Abstands zwischen zwei Elementen in der `span`.
`value_type`	Der Typ eines Elements, ohne oder `volatile` qualifikationsfrei`const`.
Konstruktor	Beschreibung
`span`	Erstellen Sie ein `span`.
Iteratorunterstützung	Beschreibung
`begin`	Rufen Sie einen Iterator ab, der auf das erste Element in der .`span`
`end`	Rufen Sie einen Iterator ab, der auf das Ende der .`span`
`rbegin`	Rufen Sie einen umgekehrten Iterator ab, der auf das letzte Element des `span`; d. h. den Anfang des umgekehrten `span`Elements zeigt.
`rend`	Rufen Sie einen umgekehrten Iterator ab, der auf die Vorderseite des `span`; d. h. das Ende des umgekehrten `span`.
Access-Elemente	Beschreibung
`back`	Rufen Sie das letzte Element in der `span`.
`data`	Rufen Sie die Adresse des ersten Elements in der `span`.
`front`	Rufen Sie das erste Element in der `span`.
`operator[]`	Greifen Sie auf ein Element an einer angegebenen Position zu.
Beobachter	Beschreibung
`empty`	Testen Sie, ob die Datei `span` leer ist.
`size`	Ruft die Anzahl der Elemente in der `span`.
`size_bytes`	Ruft die Größe der `span` in Bytes ab.
Unteransichten	Beschreibung
`first`	Rufen Sie einen Unterbereich von der Vorderseite der .`span`
`last`	Rufen Sie einen Unterbereich von der Rückseite der .`span`
`subspan`	Abrufen eines Unterbereichs von überall in der `span`.
Operatoren	Beschreibung
`span::operator=`	Ersetzen Sie die `span`.
`span::operator[]`	Rufen Sie das Element an der angegebenen Position ab.

Hinweise

Alle span Memberfunktionen weisen eine konstante Zeitkomplexität auf.

Anders als array oder vector, eine span besitzt nicht die Darin enthaltenen Elemente. Ein span Speicher wird für die darin enthaltenen Elemente nicht freigegeben, da er nicht über den Speicher für diese Objekte verfügt.

Anforderungen

Header: <span> (seit C++20)

Namespace:std

Compileroption: /std:c++20 oder höher ist erforderlich.

`span::back`

Rufen Sie das letzte Element in der span.

constexpr reference back() const noexcept;

Rückgabewert

Ein Verweis auf das letzte Element in der span.

Beispiel

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

Rufen Sie einen Iterator ab, der auf das erste Element in der .span

constexpr iterator begin() const noexcept;

Rückgabewert

Ein Iterator, der auf das erste Element in der span.

Beispiel

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

Rufen Sie einen Zeiger auf den Anfang der span Daten ab.

constexpr pointer data() const noexcept;

Rückgabewert

Ein Zeiger auf das erste element, das in der span.

Beispiel

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

Die Anzahl der Elemente zwischen zwei Elementen in einem span.

using difference_type = std::ptrdiff_t;

Beispiel

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

Der Typ der Elemente im span.

using element_type = T;

Hinweise

Der Typ wird beim Erstellen eines Vorlagenparameters aus dem Vorlagenparameter T span übernommen.

Beispiel

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

Gibt an, ob die span Elemente enthalten sind.

constexpr bool empty() const noexcept;

Rückgabewert

Gibt zurück true , wenn this->size() == 0. Andernfalls false.

Beispiel

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

Rufen Sie einen Iterator bis zum Ende der .span

constexpr iterator end() const noexcept;

Rückgabewert

Ein Iterator, der direkt über das Ende der span.

Hinweise

end wird verwendet, um zu testen, ob ein Iterator das Ende seines Bereichs übergeben hat.

Leiten Sie den von diesem Iterator zurückgegebenen Wert nicht ab. Verwenden Sie es, um zu ermitteln, ob der Iterator über das letzte Element in der .span

Beispiel

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

`span::first`

Rufen Sie einen Teilbereich ab, der von der Vorderseite dieser span.

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

Parameter

count
Die Anzahl der Elemente von vorne span , die in den Unterbereich eingefügt werden sollen.
Die Anzahl der Elemente wird als Parameter für die Vorlage oder für die Funktion angegeben, wie unten dargestellt.

Rückgabewert

Ein span Element, das count Elemente von vorne enthält span.

Hinweise

Verwenden Sie die Vorlagenversion dieser Funktion, wenn möglich, um die count Kompilierungszeit zu überprüfen, und um Informationen zu dem span , da sie ein span festes Ausmaß zurückgibt, beizubehalten.

Beispiel

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

Rufen Sie das erste Element in der span.

constexpr reference front() const noexcept;

Rückgabewert

Ein Verweis auf das erste Element in der span.

Beispiel

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

Der Typ eines iterator Überelements span .

using iterator = implementation-defined-iterator-type;

Hinweise

Dieser Typ dient als über iterator die Elemente in einem span.

Beispiel

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

Rufen Sie einen Teilbereich ab, der vom Ende dieses spanBereichs genommen wird.

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;

Parameter

count
Die Anzahl der Elemente am Ende, span die in den Unterbereich eingefügt werden sollen. Die Zahl kann als Parameter für die Vorlage oder für die Funktion angegeben werden, wie unten dargestellt.

Rückgabewert

A span containing the last count elements from this span.

Hinweise

Beispiel

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

Rufen Sie das Element an span einer angegebenen Position ab.

constexpr reference operator[](size_type offset) const;

Parameter

offset
Nullbasiertes Element im span Zugriff.

Rückgabewert

Ein Verweis auf das Element an position offset. Wenn die Position ungültig ist, ist das Verhalten nicht definiert.

Beispiel

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Weisen Sie diesem einen anderen span zu.

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

Parameter

other
Der span , der diesem zugewiesen werden soll.

Rückgabewert

*this

Bemerkungen

Die Zuordnung führt eine flache Kopie des Datenzeigers und der Größe aus. Eine flache Kopie ist sicher, da ein span Speicher für die darin enthaltenen Elemente nicht zugewiesen wird.

Beispiel

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

Die Typen für einen Zeiger und const zeiger auf ein span Element.

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

Beispiel

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

Rufen Sie einen umgekehrten Iterator ab, der auf das letzte Element dieses spanElements zeigt.

constexpr reverse_iterator rbegin() const noexcept;

Rückgabewert

Ein Iterator, der auf den Anfang des umgekehrten spanZeigers zeigt.

Beispiel

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

Die Typen für einen Verweis und einen const Verweis auf ein span Element.

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

Beispiel

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

Rufen Sie einen Iterator mit wahlfreiem Zugriff ab, der direkt über das Ende des umgekehrten spanBereichs verweist.

constexpr reverse_iterator rend() const noexcept;

Rückgabewert

Ein reverse iterator to the placeholder following the last element in the reversed span; that is, the placeholder before the first element in the unreversed span.

Hinweise

rend wird mit einem umgekehrten span verwendet, genau wie span::end bei einem span. Verwenden Sie es, um zu testen, ob ein Umgekehrter Iterator das Ende des Iterators spanerreicht hat.

Der zurückgegebene rend Wert sollte nicht abgeleitet werden.

Beispiel

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

Der Typ eines Umgekehrten Iterators für ein span.

using reverse_iterator = std::reverse_iterator<iterator>;

Beispiel

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

Ruft die Anzahl der Elemente in der span.

constexpr size_t size() const noexcept;

Rückgabewert

Die Anzahl der Elemente im span.

Beispiel

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Rufen Sie die Größe der Elemente in den span Byte ab.

constexpr size_type size_bytes() const noexcept;

Rückgabewert

Die Anzahl der Bytes, die alle Elemente in der span Besatzung enthalten; sizeof(element_type) d. h. multipliziert mit der Anzahl der Elemente in der span.

Beispiel

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

Ein nicht signierter Typ, der zum Speichern der Anzahl der Elemente in einem span.

using size_type = size_t;

Beispiel

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

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

Parameter

arr
Erstellen Eines span aus einem Array.

count
Anzahl der Elemente, die sich in der span.

first
Iterator auf das erste Element in der span.

last
Iterator, um das letzte Element in der span.

N
Die Anzahl der Elemente, die in der span.

other
Erstellen Sie eine Kopie dieser spanDatei.

r
Erstellen Eines span aus dem Bereich R.

Hinweise

Ein span Speicherplatz für Elemente wird span nicht freigegeben, da er nicht der Besitzer der Darin enthaltenen Objekte ist.

Konstruktor	Beschreibung
`span()`	Erstellen Sie eine leere `span`. Wird nur bei der Überladungsauflösung berücksichtigt, wenn der Vorlagenparameter `Extent` ist `0` oder `dynamic_extent`.
`span(It first, size_type count)`	Erstellen Sie eine `span` aus den ersten `count` Elementen aus iterator `first`. Wird nur während der Überladungsauflösung berücksichtigt, wenn der Vorlagenparameter `Extent` nicht `dynamic_extent`angegeben ist.
`span(It first, End last)`	Erstellen Sie ein `span` Element aus den Elementen im Iterator `first` , bis das Ende `last` erreicht ist. Wird nur während der Überladungsauflösung berücksichtigt, wenn der Vorlagenparameter `Extent` nicht `dynamic_extent`angegeben ist. `It` muss vom Typ `contiguous_iterator` sein.
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Erstellen Sie eine `span` aus `N` Elementen des angegebenen Arrays. Wird nur bei der Überladungsauflösung berücksichtigt, wenn der Vorlagenparameter `Extent` gleich oder gleich `N`ist`dynamic_extent`.
`span(R&& r)`	Erstellen Eines `span` aus einem Bereich. Nimmt nur an der Überladungsauflösung teil, wenn der Vorlagenparameter `Extent` nicht `dynamic_extent`vorhanden ist.
`span(const span& other)`	Der vom Compiler generierte Kopierkonstruktor. Eine flache Kopie des Datenzeigers ist sicher, da der `span` Speicher nicht zum Speichern der Elemente zugewiesen wird.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Konvertieren des Konstruktors: Erstellen eines aus einem `span` anderen `span`. Nimmt nur an der Überladungsauflösung teil, wenn der Vorlagenparameter `Extent` gleich ist `dynamic_extent`oder `N` gleich `Extent`ist`dynamic_extent`.

Beispiel

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

Rufen Sie einen Teilbereich dieses spanBereichs ab.

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

Parameter

count
Die Anzahl der Elemente, die in den Unterbereich eingefügt werden sollen. Wenn count (Standardwert) ist dynamic_extent , wird der Unterbereich von offset bis zum Ende dieses Bereichs spanübernommen.

offset
Der Speicherort, an dem span der Unterbereich gestartet werden soll.

Rückgabewert

offset Ab span diesem spanZeitpunkt . Enthält count Elemente.

Hinweise

Eine Vorlagenversion dieser Funktion ist verfügbar, mit der die Anzahl zur Kompilierungszeit überprüft wird, wodurch Informationen über das span Durch zurückgeben eines span festen Umfangs erhalten bleiben.

Beispiel

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

Der Typ des Elements in der span, ohne const oder volatile qualifikationen.

using value_type = std::remove_cv_t<T>;

Beispiel

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

Abzugslinien

Die folgenden Abzugslinien sind für 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>>>;

Siehe auch

<span>
So wird's ausgeführt: Verwenden des Klassenvorlagenargumentsabzugs

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-07

Freigeben über

span Klasse (C++-Standardbibliothek)

Syntax

Vorlagenparameter

Member

Hinweise

Anforderungen

span::back

Rückgabewert

Beispiel

span::begin

Rückgabewert

Beispiel

span::data

Rückgabewert

Beispiel

span::difference_type

Beispiel

span::element_type

Hinweise

Beispiel

span::empty

Rückgabewert

Beispiel

span::end

Rückgabewert

Hinweise

Beispiel

span::first

Parameter

Rückgabewert

Hinweise

Beispiel

span::front

Rückgabewert

Beispiel

span::iterator

Hinweise

Beispiel

span::last

Parameter

Rückgabewert

Hinweise

Beispiel

span::operator[]

Parameter

Rückgabewert

Beispiel

span::operator=

Parameter

Rückgabewert

Bemerkungen

Beispiel

span::pointer

Beispiel

span::rbegin

Rückgabewert

Beispiel

span::reference

Beispiel

span::rend

Rückgabewert

Hinweise

Beispiel

span::reverse_iterator

Beispiel

span::size

Rückgabewert

Beispiel

span::size_bytes

Rückgabewert

Beispiel

span::size_type

Beispiel

span::span

Parameter

Hinweise

Beispiel

span::subspan

Parameter

`span` Klasse (C++-Standardbibliothek)

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