`span` class (standardní knihovna jazyka C++)

Článek
10/12/2023

Poskytuje zjednodušené zobrazení nad souvislou sekvencí objektů. A span poskytuje bezpečný způsob, jak iterovat a indexovat do objektů, které jsou uspořádané zpět do paměti. Například objekty uložené v předdefinované matici nebo std::arraystd::vector.

Pokud obvykle přistupujete k posloupnosti back-to-back objektů pomocí ukazatele a indexu, span je bezpečnější a lehká alternativa.

Velikost lze span nastavit v době kompilace zadáním argumentu šablony nebo za běhu zadáním dynamic_extent.

Syntaxe

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

Parametry šablony

T
Typ prvků v souboru span.

Extent
Počet prvků v span případě, že je zadán v době kompilace. V opačném případě std::dynamic_extent , pokud bude počet prvků zadán za běhu.

Průvodce dedukcem

Členové

Definice typů	Popis
`const_pointer`	Typ ukazatele na `const` prvek.
`const_reference`	Typ odkazu na `const` prvek.
`difference_type`	Typ vzdálenosti se znaménkem mezi dvěma prvky
`element_type`	Typ elementu `span` .
`iterator`	Typ iterátoru pro .`span`
`pointer`	Typ ukazatele na prvek
`reference`	Typ odkazu na prvek
`reverse_iterator`	Typ zpětné iterátoru pro určitou `span`hodnotu .
`size_type`	Typ výsledku vzdálenosti bez znaménka mezi dvěma prvky v znaménka `span`.
`value_type`	Typ prvku bez `const` kvalifikace.`volatile`
Konstruktor	Popis
`span`	Vytvoření .`span`
Podpora iterátoru	Popis
`begin`	Získejte iterátor odkazující na první prvek v objektu `span`.
`end`	Získejte iterátor odkazující na konec `span`.
`rbegin`	Získejte reverzní iterátor odkazující na poslední prvek `span`; to znamená začátek obráceného `span`objektu .
`rend`	Získejte reverzní iterátor ukazující na přední část `span`; to znamená konec obráceného `span`objektu .
Přístupové prvky	Popis
`back`	Získejte poslední prvek v souboru `span`.
`data`	Získejte adresu prvního prvku v objektu `span`.
`front`	Získejte první prvek v objektu `span`.
`operator[]`	Přístup k prvku na zadané pozici.
Pozorovatelé	Popis
`empty`	Otestujte, jestli `span` je prázdný.
`size`	Získá počet prvků v souboru `span`.
`size_bytes`	Získejte velikost `span` v bajtech.
Podviews	Popis
`first`	Získat subspan z přední části `span`.
`last`	Získat podspan ze zadní části `span`.
`subspan`	Získejte podspan odkudkoliv v sadě `span`.
Operátory	Popis
`span::operator=`	Nahraďte položku `span`.
`span::operator[]`	Získejte prvek na zadané pozici.

Poznámky

Všechny span členské funkce mají konstantní složitost času.

Na rozdíl od array elementů v něm nebo vectorspan nespravuje prvky uvnitř. A span nemá volné úložiště pro položky uvnitř, protože vlastní úložiště pro tyto objekty.

Požadavky

Hlavička: <span> (od C++20)

Obor názvů: std

Je vyžadována možnost kompilátoru: /std:c++20 nebo novější.

`span::back`

Získejte poslední prvek v souboru span.

constexpr reference back() const noexcept;

Vrácená hodnota

Odkaz na poslední prvek v souboru span.

Příklad

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

Získejte iterátor ukazující na první prvek v objektu span.

constexpr iterator begin() const noexcept;

Vrácená hodnota

Iterátor ukazující na první prvek v objektu span.

Příklad

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

Získejte ukazatel na začátek span dat.

constexpr pointer data() const noexcept;

Vrácená hodnota

Ukazatel na první položku uloženou v objektu span.

Příklad

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

Počet prvků mezi dvěma prvky v prvku span.

using difference_type = std::ptrdiff_t;

Příklad

#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 prvků v souboru span.

using element_type = T;

Poznámky

Typ je převzat z parametru T šablony při span vytvoření.

Příklad

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

span Určuje, zda obsahuje prvky.

constexpr bool empty() const noexcept;

Vrácená hodnota

Vrátí true hodnotu if this->size() == 0. Jinak false.

Příklad

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

Získejte iterátor na konec span.

constexpr iterator end() const noexcept;

Vrácená hodnota

Iterátor ukazující těsně za koncem span.

Poznámky

end slouží k otestování, zda iterátor předal konec jeho rozsahu.

Nepřesouvejte hodnotu vrácenou tímto iterátorem. Slouží k identifikaci, zda iterátor dosáhl nad rámec posledního prvku v objektu span.

Příklad

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

`span::first`

Získejte subspan, převzatý z přední části tohoto span.

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

Parametry

count
Početprvkůch span
Počet prvků je určen jako parametr šablony nebo funkce, jak je znázorněno níže.

Vrácená hodnota

A span , který obsahuje count prvky z přední části tohoto span.

Poznámky

Pokud je to možné, použijte verzi šablony této funkce, pokud je to možné, ověřit count v době kompilace a zachovat informace o span tom, že vrací span pevný rozsah.

Příklad

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

Získejte první prvek v objektu span.

constexpr reference front() const noexcept;

Vrácená hodnota

Odkaz na první prvek v objektu span.

Příklad

#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 nad iterator span prvky.

using iterator = implementation-defined-iterator-type;

Poznámky

Tento typ slouží jako nad iterator prvky v objektu span.

Příklad

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

Získejte podspan, odebrané od konce tohoto 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
Počet prvků od konce, span které mají být vloženy do podspanu. Číslo lze zadat jako parametr šablony nebo funkci, jak je znázorněno níže.

Vrácená hodnota

A span obsahující poslední count prvky z tohoto span.

Poznámky

Pokud je to možné, použijte verzi šablony této funkce, pokud je to možné, ověřit count v době kompilace a zachovat informace o span tom, že vrací span pevný rozsah.

Příklad

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

Získá prvek v span zadané pozici.

constexpr reference operator[](size_type offset) const;

Parametry

offset
Prvek založený na nule v přístupovém span prvku.

Vrácená hodnota

Odkaz na prvek na pozici offset. Pokud je pozice neplatná, chování není definováno.

Příklad

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Přiřaďte další span k tomuto.

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

Parametry

other
Přiřazení span k tomuto.

Vrácená hodnota

*this

Poznámky

Přiřazení provede mělkou kopii ukazatele na data a velikost. Mělká kopie je bezpečná, protože span nepřiděluje paměť prvkům, které obsahuje.

Příklad

#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 ukazatele a const ukazatele na span prvek.

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

Příklad

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

Získejte reverzní iterátor odkazující na poslední prvek tohoto spanobjektu .

constexpr reverse_iterator rbegin() const noexcept;

Vrácená hodnota

Iterátor směřující na začátek obráceného spanobjektu .

Příklad

#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 pro odkaz a const odkaz na span prvek.

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

Příklad

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

Získejte iterátor náhodného přístupu, který odkazuje těsně za koncem obráceného spanobjektu .

constexpr reverse_iterator rend() const noexcept;

Vrácená hodnota

Reverzní iterátor na zástupný symbol následující za posledním prvkem v obráceném spansměru ; to znamená zástupný symbol před prvním prvkem v nereverze .span

Poznámky

rend se používá s obráceným opakem span , stejně jako span::end se používá s span. Slouží k otestování, zda reverzní iterátor dosáhl konce jeho span.

Hodnota vrácená rend by neměla být dereferenced.

Příklad

#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 zpětné iterátoru pro určitou spanhodnotu .

using reverse_iterator = std::reverse_iterator<iterator>;

Příklad

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

Získá počet prvků v souboru span.

constexpr size_t size() const noexcept;

Vrácená hodnota

Počet prvků v souboru span.

Příklad

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Získejte velikost prvků v span bajtech.

constexpr size_type size_bytes() const noexcept;

Vrácená hodnota

Počet bajtů, které všechny prvky v obsazení span zabírají; to znamená vynásobené sizeof(element_type) počtem prvků v spansadě .

Příklad

#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 bez znaménka vhodný pro uložení počtu prvků v objektu span.

using size_type = size_t;

Příklad

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

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
Vytvořte z span pole.

count
Počet prvků, které budou v spansouboru .

first
Iterátor na první prvek v objektu span.

last
Iterátor pro poslední prvek v objektu span.

N
Počet prvků, které budou v spansouboru .

other
Vytvořte kopii tohoto spansouboru .

r
span Vytvořit z rozsahu R.

Poznámky

A span nemá volné úložiště pro položky v objektu span , protože nevlastní úložiště objektů v něm.

Konstruktor	Popis
`span()`	Vytvoření prázdného `span`objektu . Pouze při řešení přetížení, pokud je `0` parametr `Extent` šablony nebo `dynamic_extent`.
`span(It first, size_type count)`	`span` Vytvořte z prvních `count` prvků z iterátoru `first`. Pouze při řešení přetížení, pokud parametr `Extent` šablony není `dynamic_extent`.
`span(It first, End last)`	`span` Vytvořte z prvků v iterátoru `first` až do dosažení konce`last`. Pouze při řešení přetížení, pokud parametr `Extent` šablony není `dynamic_extent`. `It`musí být .`contiguous_iterator`
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Vytvořte z `span` `N` prvků zadaného pole. Pouze při řešení přetížení, pokud je `dynamic_extent` parametr `Extent` šablony nebo roven `N`.
`span(R&& r)`	Vytvořte z rozsahu `span` . Pouze se účastní řešení přetížení, pokud parametr `Extent` šablony není `dynamic_extent`.
`span(const span& other)`	Konstruktor kopírování vygenerovaný kompilátorem. Mělká kopie datového ukazatele je bezpečná, protože `span` nepřiděluje paměť pro uložení prvků.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Převod konstruktoru: konstrukce `span` z jiného `span`. Účastní se pouze řešení přetížení, pokud je parametr `Extent` šablony , nebo `N` je `dynamic_extent` nebo je roven `Extent`.`dynamic_extent`

Příklad

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

Získejte podsložku tohoto spansouboru .

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
Počet prvků, které mají být vloženy do podspanu. Pokud count je dynamic_extent (výchozí hodnota), je subspan převzat od offset konce tohoto spanparametru .

offset
Umístění v tomto span umístění pro spuštění podspanu.

Vrácená hodnota

offset Začíná span v tomhle span. Obsahuje count prvky.

Poznámky

K dispozici je verze šablony této funkce, která kontroluje počet v době kompilace, která zachovává informace o span vrácením span pevného rozsahu.

Příklad

#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 prvku v objektu span, bez const kvalifikace.volatile

using value_type = std::remove_cv_t<T>;

Příklad

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

Průvodci odpočtem

Následující odpočtové příručky jsou poskytovány pro 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>>>;

Viz také

<span>
Jak používat odpočty argumentů šablony třídy

Sdílet prostřednictvím

span class (standardní knihovna jazyka C++)

Syntaxe

Parametry šablony

Členové

Poznámky

Požadavky

span::back

Vrácená hodnota

Příklad

span::begin

Vrácená hodnota

Příklad

span::data

Vrácená hodnota

Příklad

span::difference_type

Příklad

span::element_type

Poznámky

Příklad

span::empty

Vrácená hodnota

Příklad

span::end

Vrácená hodnota

Poznámky

Příklad

span::first

Parametry

Vrácená hodnota

Poznámky

Příklad

span::front

Vrácená hodnota

Příklad

span::iterator

Poznámky

Příklad

span::last

Parametry

Vrácená hodnota

Poznámky

Příklad

span::operator[]

Parametry

Vrácená hodnota

Příklad

span::operator=

Parametry

Vrácená hodnota

Poznámky

Příklad

span::pointer

Příklad

span::rbegin

Vrácená hodnota

Příklad

span::reference

Příklad

span::rend

Vrácená hodnota

Poznámky

Příklad

span::reverse_iterator

Příklad

span::size

Vrácená hodnota

Příklad

span::size_bytes

Vrácená hodnota

Příklad

span::size_type

Příklad

span::span

Parametry

Poznámky

Příklad

span::subspan

Parametry

`span` class (standardní knihovna jazyka 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`