std:: span

Die Klassenvorlage span beschreibt ein Objekt, das sich auf eine zusammenhängende Folge von Objekten beziehen kann, wobei sich das erste Element der Folge an Position null befindet. Ein span kann entweder eine static Ausdehnung haben, wobei die Anzahl der Elemente in der Folge zur Kompilierzeit bekannt und im Typ kodiert ist, oder eine dynamic 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.

Template-Parameter

Verschachtelte Typen

1. ↑ iterator ist ein veränderlicher Iterator, falls T nicht const-qualifiziert ist.

Alle Anforderungen an die Iteratortypen eines Container gelten ebenfalls für den iterator -Typ von span .

Datenmitglieder

Memberfunktionen

Nicht-Member-Funktionen

Hilfskonstante

Hilfsvorlagen

Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass span die Anforderungen von borrowed_range erfüllt.

Diese Spezialisierung von ranges::enable_view bewirkt, dass span die Anforderungen von view erfüllt.

Deduktionshilfen

Hinweise

Spezialisierungen von std::span sind bereits in allen existierenden Implementierungen trivial kopierbare Typen, sogar vor der formalen Anforderung, die in C++23 eingeführt wurde.

Beispiel

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

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

Fehlerberichte

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

Siehe auch