Udostępnij za pośrednictwem


span class (Standardowa biblioteka C++)

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

Elementy członkowskie

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 spanelementu , czyli początek odwróconego spanelementu .
rend Pobierz iterator odwrotny wskazujący na przednią część spanobiektu , czyli koniec odwróconego spanelementu .
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)

Przestrzeń 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();
}
2

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

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

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

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

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

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

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];
}
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;
    }
}
012

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

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

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

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

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();
}
3

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)
}
12

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

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 spanelement . 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_extentjest .
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_extentjest . Itmusi 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 Nrówny .
span(R&& r) Konstruowanie elementu span z zakresu. Uczestniczy tylko w rozwiązywaniu przeciążeń, jeśli parametr Extent szablonu nie dynamic_extentjest .
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 spanobiektu . 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;
}
2

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