`span` class (Standardowa biblioteka C++)

Artykuł
10/12/2023

Zapewnia uproszczony widok w ciągłej sekwencji obiektów. Element zapewnia span bezpieczny sposób iteracji i indeksowania do obiektów, które są rozmieszczone z powrotem w pamięci. Na przykład obiekty przechowywane w wbudowanej tablicy, std::arraylub std::vector.

Jeśli zazwyczaj uzyskujesz dostęp do sekwencji obiektów back-to-back przy użyciu wskaźnika i indeksu, jest to bezpieczniejsza, span uproszczona alternatywa.

Rozmiar obiektu span można ustawić w czasie kompilacji, określając go jako argument szablonu lub w czasie wykonywania, określając wartość dynamic_extent.

Składnia

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

Parametry szablonu

T
Typ elementów w obiekcie span.

Extent
Liczba elementów w span pliku , jeśli określono w czasie kompilacji. W przeciwnym razie std::dynamic_extent , jeśli liczba elementów zostanie określona w czasie wykonywania.

Przewodnik po odliczeniu

Członkowie

Definicje typu	Opis
`const_pointer`	Typ wskaźnika do `const` elementu.
`const_reference`	Typ odwołania do `const` elementu.
`difference_type`	Typ odległości ze znakiem między dwoma elementami.
`element_type`	Typ `span` elementu.
`iterator`	Typ iteratora dla elementu `span`.
`pointer`	Typ wskaźnika do elementu.
`reference`	Typ odwołania do elementu.
`reverse_iterator`	Typ iteratora odwrotnego dla elementu `span`.
`size_type`	Typ wyniku niepodpisanej odległości między dwoma elementami w obiekcie `span`.
`value_type`	Typ elementu, bez `const` kwalifikacji lub `volatile` .
Konstruktor	Opis
`span`	Skonstruuj element `span`.
Obsługa iteratora	Opis
`begin`	Pobierz iterator wskazujący pierwszy element w elemecie `span`.
`end`	Pobierz iterator wskazujący na koniec elementu `span`.
`rbegin`	Pobierz iterator odwrotny wskazujący ostatni element `span`elementu , czyli początek odwróconego `span`elementu .
`rend`	Pobierz iterator odwrotny wskazujący na przednią część `span`obiektu , czyli koniec odwróconego `span`elementu .
Elementy dostępu	Opis
`back`	Pobierz ostatni element w elemecie `span`.
`data`	Pobierz adres pierwszego elementu w elemecie `span`.
`front`	Pobierz pierwszy element w elemecie `span`.
`operator[]`	Uzyskaj dostęp do elementu w określonej pozycji.
Obserwatorów	Opis
`empty`	Sprawdź, czy element `span` jest pusty.
`size`	Pobierz liczbę elementów w elemecie `span`.
`size_bytes`	Pobierz rozmiar `span` w bajtach.
Przeglądy podrzędne	Opis
`first`	Pobierz podzbień z przodu obiektu `span`.
`last`	Pobierz podzbień z tyłu obiektu `span`.
`subspan`	Pobierz podzbień z dowolnego miejsca w obiekcie `span`.
Operatory	Opis
`span::operator=`	Zastąp element `span`.
`span::operator[]`	Pobierz element na określonej pozycji.

Uwagi

Wszystkie span funkcje składowe mają stałą złożoność czasu.

W przeciwieństwie do array elementu lub vector, element span nie jest "właścicielem" wewnątrz elementu. Obiekt span nie zwalnia żadnego magazynu dla elementów znajdujących się w nim, ponieważ nie jest właścicielem magazynu dla tych obiektów.

Wymagania

Nagłówek:<span> (od C++20)

Obszaru nazw:std

Opcja kompilatora:/std:c++20 lub nowsza jest wymagana.

`span::back`

Pobierz ostatni element w elemecie span.

constexpr reference back() const noexcept;

Wartość zwracana

Odwołanie do ostatniego elementu w elemencie span.

Przykład

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

Pobierz iterator wskazujący pierwszy element w elemecie span.

constexpr iterator begin() const noexcept;

Wartość zwracana

Iterator wskazujący pierwszy element w elemecie span.

Przykład

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

Pobierz wskaźnik na początek span danych.

constexpr pointer data() const noexcept;

Wartość zwracana

Wskaźnik do pierwszego elementu przechowywanego w elemencie span.

Przykład

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

Liczba elementów między dwoma elementami w obiekcie span.

using difference_type = std::ptrdiff_t;

Przykład

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

Typ elementów w obiekcie span.

using element_type = T;

Uwagi

Typ jest pobierany z parametru T szablonu podczas span tworzenia.

Przykład

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

Czy element span zawiera elementy.

constexpr bool empty() const noexcept;

Wartość zwracana

Zwraca wartość true if this->size() == 0. W przeciwnym razie false.

Przykład

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

Pobierz iterator na końcu elementu span.

constexpr iterator end() const noexcept;

Wartość zwracana

Iterator wskazujący tuż poza końcem elementu span.

Uwagi

end służy do testowania, czy iterator przeszedł koniec jego zakresu.

Nie wyłuszaj wartości zwracanej przez ten iterator. Użyj go, aby określić, czy iterator osiągnął więcej niż ostatni element w elemecie span.

Przykład

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

`span::first`

Pobierz podpan, pobrany z przodu tego spanelementu .

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

Parametry

count
Liczba elementów z przodu tej span funkcji do umieszczenia w podspanie.
Liczba elementów jest określana jako parametr szablonu lub funkcji, jak pokazano poniżej.

Wartość zwracana

Element span zawierający count elementy z przodu tego spanelementu .

Uwagi

Użyj wersji szablonu tej funkcji, jeśli jest to możliwe, aby zweryfikować count element w czasie kompilacji i zachować informacje o span tym, ponieważ zwraca span stały zakres.

Przykład

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

Pobierz pierwszy element w elemecie span.

constexpr reference front() const noexcept;

Wartość zwracana

Odwołanie do pierwszego elementu w elemencie span.

Przykład

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

Typ iterator elementu powyżej span .

using iterator = implementation-defined-iterator-type;

Uwagi

Ten typ służy jako element iterator ponad elementami w obiekcie span.

Przykład

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

Pobierz podspan pobrany z końca tego elementu span.

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;

Parametry

count
Liczba elementów od końca do span umieszczenia w podpanie. Liczbę można określić jako parametr szablonu lub funkcji, jak pokazano poniżej.

Wartość zwracana

Element span zawierający ostatnie count elementy z tego spanelementu .

Uwagi

Użyj wersji szablonu tej funkcji, jeśli jest to możliwe, aby zweryfikować count element w czasie kompilacji i zachować informacje o span tym, ponieważ zwraca span stały zakres.

Przykład

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

Pobierz element w span określonej pozycji.

constexpr reference operator[](size_type offset) const;

Parametry

offset
Zero-based element w celu span uzyskania dostępu.

Wartość zwracana

Odwołanie do elementu w pozycji offset. Jeśli pozycja jest nieprawidłowa, zachowanie jest niezdefiniowane.

Przykład

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Przypisz inny span do tego.

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

Parametry

other
Element span do przypisania do tego.

Wartość zwracana

*this

Uwagi

Przypisanie wykonuje płytkią kopię wskaźnika danych i rozmiar. Płytkia kopia jest bezpieczna, ponieważ span element nie przydziela pamięci dla zawartych w nim elementów.

Przykład

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

Typy wskaźnika i const wskaźnika do span elementu.

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

Przykład

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

Pobierz iterator odwrotny wskazujący ostatni element tego spanelementu .

constexpr reverse_iterator rbegin() const noexcept;

Wartość zwracana

Iterator wskazujący początek odwróconego spanelementu .

Przykład

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

Typy odwołania i const odwołanie do span elementu.

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

Przykład

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

Uzyskaj iterator dostępu losowego, który wskazuje tuż za końcem odwróconego spanelementu .

constexpr reverse_iterator rend() const noexcept;

Wartość zwracana

Iterator odwrotny do symbolu zastępczego następującego ostatniego elementu w odwróconym spanelemecie ; oznacza to, że symbol zastępczy przed pierwszym elementem w niewróceniu span.

Uwagi

rend jest używany z odwróconym span elementem, tak jak span::end jest używany z elementem span. Użyj go, aby sprawdzić, czy iterator odwrotny osiągnął koniec jego span.

Wartość zwracana przez rend nie powinna być wyłuszczone.

Przykład

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

Typ iteratora odwrotnego dla elementu span.

using reverse_iterator = std::reverse_iterator<iterator>;

Przykład

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

Pobierz liczbę elementów w elemecie span.

constexpr size_t size() const noexcept;

Wartość zwracana

Liczba elementów w elem.span

Przykład

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Pobierz rozmiar elementów w bajtach span .

constexpr size_type size_bytes() const noexcept;

Wartość zwracana

Liczba bajtów, które wszystkie elementy zajmowane span , czyli sizeof(element_type) mnożone przez liczbę elementów w obiekcie span.

Przykład

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

Typ niepodpisany, odpowiedni do przechowywania liczby elementów w obiekcie span.

using size_type = size_t;

Przykład

#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 Konstruktorów.

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

Parametry

arr
Konstruowanie obiektu span z tablicy.

count
Liczba elementów, które będą znajdować się w obiekcie span.

first
Iterator do pierwszego elementu w pliku span.

last
Iterator po prostu przeszłości ostatniego elementu w elemecie span.

N
Liczba elementów, które będą znajdować się w obiekcie span.

other
Utwórz kopię tego elementu span.

r
Skonstruuj element span z zakresu R.

Uwagi

Obiekt span nie zwalnia miejsca do magazynowania elementów w obiekcie span , ponieważ nie jest właścicielem magazynu obiektów w nim.

Konstruktor	opis
`span()`	Skonstruuj pusty `span`element . Rozważane tylko podczas rozwiązywania przeciążenia, gdy parametr `Extent` szablonu to `0` lub `dynamic_extent`.
`span(It first, size_type count)`	Skonstruuj element `span` z pierwszych `count` elementów iteratora `first`. Rozważane tylko podczas rozwiązywania przeciążenia, gdy parametr `Extent` szablonu nie `dynamic_extent`jest .
`span(It first, End last)`	Skonstruuj element `span` z elementów w iteratorze `first` do momentu osiągnięcia końca `last` . Rozważane tylko podczas rozwiązywania przeciążenia, gdy parametr `Extent` szablonu nie `dynamic_extent`jest . `It`musi być .`contiguous_iterator`
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Konstruowanie elementu `span` z `N` elementów określonej tablicy. Rozważane tylko podczas rozwiązywania przeciążeń, gdy parametr `Extent` szablonu jest `dynamic_extent` lub jest `N`równy .
`span(R&& r)`	Konstruowanie elementu `span` z zakresu. Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli parametr `Extent` szablonu nie `dynamic_extent`jest .
`span(const span& other)`	Konstruktor kopiowania wygenerowany przez kompilator. Płytkia kopia wskaźnika danych jest bezpieczna, ponieważ `span` pamięć nie jest przydzielana do przechowywania elementów.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Konwertujący konstruktor: skonstruuj element `span` z innego `span`obiektu . Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli parametr `Extent` szablonu to `dynamic_extent`, lub `N` jest `dynamic_extent` lub równa `Extent`.

Przykład

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

Pobierz podgrupę tego spanobiektu .

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

Parametry

count
Liczba elementów do umieszczenia w podspanie. Jeśli count to dynamic_extent (wartość domyślna), podspan jest pobierany z offset do końca tego spanelementu .

offset
Lokalizacja w tym span celu, aby uruchomić podspan.

Wartość zwracana

Element span rozpoczynający się od offset tego span. Zawiera count elementy.

Uwagi

Dostępna jest wersja szablonu tej funkcji, która sprawdza liczbę w czasie kompilacji, która zachowuje informacje o span obiekcie przez zwrócenie span stałego zakresu.

Przykład

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

Typ elementu w elemecie span, bez const lub volatile kwalifikacje.

using value_type = std::remove_cv_t<T>;

Przykład

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

Przewodniki odliczeń

Następujące przewodniki dotyczące potrąceń są dostępne dla elementu 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>>>;

Zobacz też

<span>
Jak używać odliczenia argumentu szablonu klasy

Udostępnij przez

span class (Standardowa biblioteka C++)

Składnia

Parametry szablonu

Członkowie

Uwagi

Wymagania

span::back

Wartość zwracana

Przykład

span::begin

Wartość zwracana

Przykład

span::data

Wartość zwracana

Przykład

span::difference_type

Przykład

span::element_type

Uwagi

Przykład

span::empty

Wartość zwracana

Przykład

span::end

Wartość zwracana

Uwagi

Przykład

span::first

Parametry

Wartość zwracana

Uwagi

Przykład

span::front

Wartość zwracana

Przykład

span::iterator

Uwagi

Przykład

span::last

Parametry

Wartość zwracana

Uwagi

Przykład

span::operator[]

Parametry

Wartość zwracana

Przykład

span::operator=

Parametry

Wartość zwracana

Uwagi

Przykład

span::pointer

Przykład

span::rbegin

Wartość zwracana

Przykład

span::reference

Przykład

span::rend

Wartość zwracana

Uwagi

Przykład

span::reverse_iterator

Przykład

span::size

Wartość zwracana

Przykład

span::size_bytes

Wartość zwracana

Przykład

span::size_type

Przykład

span::span

Parametry

Uwagi

Przykład

span::subspan

Parametry

`span` class (Standardowa biblioteka C++)

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