Namensräume
Varianten
Aktionen

std::span

Von cppreference.com
< cpp‎ | container
 
C++
 
Container-Bibliothek
 
std::span
 
Definiert in Header <span>
template<

    class T,
    std::size_t Extent = std::dynamic_extent

> class span;
 (seit C++20)

Die Klassenschablone span beschreibt ein Objekt, das auf eine zusammenhängende Sequenz von Objekten verweisen kann, wobei das erste Element der Sequenz an Position Null steht. Ein span kann entweder eine statische Ausdehnung (Extent) haben, in diesem Fall ist die Anzahl der Elemente in der Sequenz zur Compile-Zeit bekannt und im Typ kodiert, oder eine dynamische Ausdehnung.

Für einen span s werden Zeiger, Iteratoren und Referenzen auf Elemente von s ungültig, wenn eine Operation einen Zeiger im Bereich [s.data(), s.data() + s.size()) ungültig macht.

Jede Spezialisierung von std::span ist ein TriviallyCopyable-Typ.

 (seit C++23)

Eine typische Implementierung speichert einen Zeiger auf T; wenn die Ausdehnung dynamisch ist, speichert die Implementierung auch eine Größe.

Inhalt

[edit] Schablonenparameter

T - Elementtyp; muss ein vollständiger Objekttyp sein, der kein abstrakter Klassentyp ist
Extent (Ausdehnung) - die Anzahl der Elemente in der Sequenz oder std::dynamic_extent, wenn dynamisch

[edit] Member-Typen

Mitgliedertyp Definition
element_type T
value_type std::remove_cv_t<T>
size_type std::size_t
difference_type std::ptrdiff_t
Zeiger T*
const_pointer const T*
Referenz T&
const_reference const T&
iterator implementierungsdefinierter LegacyRandomAccessIterator, ConstexprIterator und contiguous_iterator, dessen value_type value_type ist
const_iterator (seit C++23) std::const_iterator<iterator>
reverse_iterator std::reverse_iterator<iterator>
const_reverse_iterator (seit C++23) std::const_iterator<reverse_iterator>

Hinweis: iterator ist ein veränderbarer Iterator, wenn T nicht mit const qualifiziert ist.

Alle Anforderungen an die Iterator-Typen eines Containers gelten auch für den iterator-Typ von span.

[edit] Member-Konstante

Name Wert
constexpr std::size_t extent
[static]
 Extent (Ausdehnung)
(öffentliche statische Member-Konstante)

[edit] Member-Funktionen

 konstruiert einen span
(öffentliche Member-Funktion) [edit]
 weist einen span zu
(öffentliche Member-Funktion) [edit]
(Destruktor)
(implizit deklariert)
 destruiert einen span
(öffentliche Memberfunktion)
Iteratoren
(C++23)
 gibt einen Iterator zum Anfang zurück
(public member function) [edit]
(C++23)
 gibt einen Iterator zum Ende zurück
(public member function) [edit]
(C++23)
 gibt einen Reverse-Iterator zum Anfang zurück
(public member function) [edit]
(C++23)
 gibt einen Reverse-Iterator zum Ende zurück
(public member function) [edit]
Elementzugriff
 Greift auf das erste Element zu
(public member function) [edit]
 Greift auf das letzte Element zu
(public member function) [edit]
(C++26)
 Greift mit Überprüfung auf ein bestimmtes Element zu
(public member function) [edit]
 Greift auf ein bestimmtes Element zu
(public member function) [edit]
 Direkter Zugriff auf den zugrundeliegenden zusammenhängenden Speicher
(public member function) [edit]
Observer
 Gibt die Anzahl der Elemente zurück
(public member function) [edit]
 gibt die Größe der Sequenz in Bytes zurück
(öffentliche Member-Funktion) [edit]
 prüft, ob die Sequenz leer ist
(öffentliche Member-Funktion) [edit]
Unteransichten (Subviews)
 erstellt eine Unteransicht (subspan), die die ersten N Elemente der Sequenz enthält
(öffentliche Member-Funktion) [edit]
 erstellt eine Unteransicht (subspan), die die letzten N Elemente der Sequenz enthält
(öffentliche Member-Funktion) [edit]
 erstellt eine Unteransicht (subspan)
(öffentliche Member-Funktion) [edit]

[edit] Nicht-Member-Funktionen

(C++20)
 konvertiert einen span in eine Ansicht seiner zugrunde liegenden Bytes
(Funktionsschablone) [edit]

[edit] Nicht-Member-Konstante

(C++20)
 eine Konstante vom Typ std::size_t, die angibt, dass der span eine dynamische Ausdehnung hat
(Konstante) [edit]

[edit] Hilfsschablonen

template< class T, std::size_t Extent >
constexpr bool ranges::enable_borrowed_range<std::span<T, Extent>> = true;
 (seit C++20)

Diese Spezialisierung von ranges::enable_borrowed_range lässt span borrowed_range erfüllen.

template< class T, std::size_t Extent >
constexpr bool ranges::enable_view<std::span<T, Extent>> = true;
 (seit C++20)

Diese Spezialisierung von ranges::enable_view lässt span view erfüllen.

[edit] Deduktionshilfen

[edit] Hinweise

Spezialisierungen von std::span sind bereits triviale Kopiertypen in allen existierenden Implementierungen, auch vor der formalen Anforderung, die in C++23 eingeführt wurde.

Feature-Test-Makro Wert Std Feature
__cpp_lib_span 202002L (C++20) std::span
202311L (C++26) std::span::at
__cpp_lib_span_initializer_list 202311L (C++26) Konstruktion von std::span aus einer std::initializer_list

[edit] Beispiel

Das Beispiel verwendet std::span, um einige Algorithmen auf zusammenhängenden Bereichen zu implementieren.

Führen Sie diesen Code aus
#include <algorithm>
#include <cstddef>
#include <iostream>
#include <span>
 
template<class T, std::size_t N>
[[nodiscard]]
constexpr auto slide(std::span<T, N> s, std::size_t offset, std::size_t width)
{
    return s.subspan(offset, offset + width <= s.size() ? width : 0U);
}
 
template<class T, std::size_t N, std::size_t M>
constexpr bool starts_with(std::span<T, N> data, std::span<T, M> prefix)
{
    return data.size() >= prefix.size()
        && std::equal(prefix.begin(), prefix.end(), data.begin());
}
 
template<class T, std::size_t N, std::size_t M>
constexpr bool ends_with(std::span<T, N> data, std::span<T, M> suffix)
{
    return data.size() >= suffix.size()
        && std::equal(data.end() - suffix.size(), data.end(),
                      suffix.end() - suffix.size());
}
 
template<class T, std::size_t N, std::size_t M>
constexpr bool contains(std::span<T, N> span, std::span<T, M> sub)
{
    return std::ranges::search(span, sub).begin() != span.end();
}
 
void println(const auto& seq)
{
    for (const auto& elem : seq)
        std::cout << elem << ' ';
    std::cout << '\n';
}
 
int main()
{
    constexpr int a[]{0, 1, 2, 3, 4, 5, 6, 7, 8};
    constexpr int b[]{8, 7, 6};
    constexpr static std::size_t width{6};
 
    for (std::size_t offset{}; ; ++offset)
        if (auto s = slide(std::span{a}, offset, width); !s.empty())
            println(s);
        else
            break;
 
    static_assert(""
        && starts_with(std::span{a}, std::span{a, 4})
        && starts_with(std::span{a + 1, 4}, std::span{a + 1, 3})
        && !starts_with(std::span{a}, std::span{b})
        && !starts_with(std::span{a, 8}, std::span{a + 1, 3})
        && ends_with(std::span{a}, std::span{a + 6, 3})
        && !ends_with(std::span{a}, std::span{a + 6, 2})
        && contains(std::span{a}, std::span{a + 1, 4})
        && !contains(std::span{a, 8}, std::span{a, 9})
    );
}

Ausgabe

0 1 2 3 4 5
1 2 3 4 5 6
2 3 4 5 6 7
3 4 5 6 7 8

[edit] Fehlerberichte

Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3203 C++20 es war unklar, wann die Zeiger, Iteratoren und
Referenzen auf Elemente von span ungültig werden		 wurde klargestellt
LWG 3903 C++20 die Deklaration des Destruktors von span war unnötig die Deklaration wurde entfernt
P2325R3 C++20 ein span mit statischer Ausdehnung ungleich Null war keine view jeder span ist eine view

[edit] Siehe auch

(C++23)
 eine mehrdimensionale, nicht-besitzende Array-View
(Klassenvorlage) [edit]
(C++20)
 kombiniert ein Iterator-Sentinel-Paar zu einer view
(Klassenschablone) [edit]
(C++11)
 verweist auf ein temporäres Array, das in der Listeninitialisierung erstellt wurde
(Klassenvorlage) [edit]
(C++17)
 schreibgeschützte String-Ansicht
(class template) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/container/span&oldid=176449"