`span` kelas (Pustaka Standar C++)

Memberikan tampilan ringan atas urutan objek yang berdampingan. menyediakan span cara yang aman untuk melakukan iterasi dan indeks ke dalam objek yang diatur kembali ke belakang dalam memori. Seperti objek yang disimpan dalam array bawaan, , std::arrayatau std::vector.

Jika Anda biasanya mengakses urutan objek back-to-back menggunakan pointer dan indeks, span adalah alternatif yang lebih aman dan ringan.

Ukuran span dapat diatur pada waktu kompilasi dengan menentukannya sebagai argumen templat, atau pada runtime dengan menentukan dynamic_extent.

Sintaks

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

Parameter template

T
Jenis elemen dalam span.

Extent
Jumlah elemen dalam span jika ditentukan pada waktu kompilasi. Jika tidak std::dynamic_extent , jika jumlah elemen akan ditentukan pada run-time.

Panduan pengurangan

Anggota

Definisi Jenis	Keterangan
`const_pointer`	Jenis penunjuk ke `const` elemen.
`const_reference`	Jenis referensi ke `const` elemen.
`difference_type`	Jenis jarak yang ditandatangani antara dua elemen.
`element_type`	Jenis `span` elemen.
`iterator`	Jenis iterator untuk `span`.
`pointer`	Jenis penunjuk ke elemen.
`reference`	Jenis referensi ke elemen.
`reverse_iterator`	Jenis iterator terbalik untuk `span`.
`size_type`	Jenis untuk hasil jarak yang tidak ditandatangani antara dua elemen dalam `span`.
`value_type`	Jenis elemen, tanpa `const` atau `volatile` kualifikasi.
Pembangun	Keterangan
`span`	`span`Buat .
Dukungan iterator	Keterangan
`begin`	Dapatkan iterator yang menunjuk ke elemen pertama di `span`.
`end`	Dapatkan iterator yang menunjuk ke akhir `span`.
`rbegin`	Dapatkan iterator terbalik yang menunjuk ke elemen `span`terakhir ; yaitu, awal terbalik `span`.
`rend`	Dapatkan iterator terbalik yang menunjuk ke depan `span`; yaitu, akhir dari terbalik `span`.
Elemen Access	Keterangan
`back`	Dapatkan elemen terakhir di `span`.
`data`	Dapatkan alamat elemen pertama di `span`.
`front`	Dapatkan elemen pertama di `span`.
`operator[]`	Akses elemen pada posisi tertentu.
Pengamat	Keterangan
`empty`	Uji apakah `span` kosong.
`size`	Dapatkan jumlah elemen di `span`.
`size_bytes`	Dapatkan ukuran `span` dalam byte.
Sub-gambaran	Keterangan
`first`	Dapatkan subspan dari depan `span`.
`last`	Dapatkan subspan dari bagian `span`belakang .
`subspan`	Dapatkan subspan dari mana saja di `span`.
Operator	Keterangan
`span::operator=`	`span`Ganti .
`span::operator[]`	Dapatkan elemen pada posisi yang ditentukan.

Keterangan

Semua span fungsi anggota memiliki kompleksitas waktu yang konstan.

Tidak seperti array atau vector, span tidak "memiliki" elemen di dalamnya. span Tidak membebaskan penyimpanan apa pun untuk item di dalamnya karena tidak memiliki penyimpanan untuk objek tersebut.

Persyaratan

Header: <span> (sejak C++20)

kumpulan nama XML: std

Opsi Pengkompilasi: /std:c++20 atau yang lebih baru diperlukan.

`span::back`

Dapatkan elemen terakhir di span.

constexpr reference back() const noexcept;

Nilai hasil

Referensi ke elemen terakhir di span.

Contoh

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

Dapatkan iterator yang menunjuk pada elemen pertama di span.

constexpr iterator begin() const noexcept;

Nilai hasil

Iterator yang menunjuk pada elemen pertama di span.

Contoh

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

Dapatkan penunjuk ke awal span data.

constexpr pointer data() const noexcept;

Nilai hasil

Penunjuk ke item pertama yang disimpan di span.

Contoh

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

Jumlah elemen antara dua elemen dalam .span

using difference_type = std::ptrdiff_t;

Contoh

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

Jenis elemen dalam span.

using element_type = T;

Keterangan

Jenis diambil dari parameter T templat saat span dibuat.

Contoh

#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 Apakah berisi elemen.

constexpr bool empty() const noexcept;

Nilai hasil

Mengembalikan true jika this->size() == 0. Jika tidak false, .

Contoh

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

Dapatkan iterator ke akhir span.

constexpr iterator end() const noexcept;

Nilai hasil

Iterator yang menunjuk tepat di luar akhir span.

Keterangan

end digunakan untuk menguji apakah iterator telah melewati akhir rentangnya.

Jangan dereferensikan nilai yang dikembalikan oleh iterator ini. Gunakan untuk mengidentifikasi apakah iterator telah mencapai melampaui elemen terakhir di span.

Contoh

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

`span::first`

Dapatkan subspan, diambil dari depan ini span.

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

Parameter

count
Jumlah elemen dari depan ini span untuk dimasukkan ke dalam subspan.
Jumlah elemen ditentukan sebagai parameter ke templat, atau ke fungsi, seperti yang diilustrasikan di bawah ini.

Nilai hasil

span yang berisi count elemen dari depan ini span.

Keterangan

Gunakan versi templat fungsi ini jika memungkinkan untuk memvalidasi pada waktu kompilasi count , dan untuk mempertahankan info tentang span karena mengembalikan span tingkat tetap.

Contoh

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

Dapatkan elemen pertama di span.

constexpr reference front() const noexcept;

Nilai hasil

Referensi ke elemen pertama di span.

Contoh

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

Jenis elemen over iterator span .

using iterator = implementation-defined-iterator-type;

Keterangan

Jenis ini berfungsi sebagai iterator lebih dari elemen dalam span.

Contoh

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

Dapatkan subspan, diambil dari akhir ini 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;

Parameter

count
Jumlah elemen dari akhir ini span untuk dimasukkan ke dalam subspan. Angka dapat ditentukan sebagai parameter ke templat, atau ke fungsi, seperti yang diilustrasikan di bawah ini.

Nilai hasil

Yang span berisi elemen terakhir count dari ini span.

Keterangan

Gunakan versi templat fungsi ini jika memungkinkan untuk memvalidasi pada waktu kompilasi count , dan untuk mempertahankan info tentang span karena mengembalikan span tingkat tetap.

Contoh

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

Dapatkan elemen pada span posisi yang ditentukan.

constexpr reference operator[](size_type offset) const;

Parameter

offset
Elemen berbasis nol dalam span akses ke.

Nilai hasil

Referensi ke elemen pada posisi offset. Jika posisi tidak valid, perilaku tidak terdefinisi.

Contoh

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Tetapkan yang lain span untuk yang satu ini.

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

Parameter

other
yang span akan ditetapkan untuk yang satu ini.

Nilai hasil

*this

Keterangan

Penugasan melakukan salinan pointer data dangkal dan ukurannya. Salinan dangkal aman karena span tidak mengalokasikan memori untuk elemen yang dikandungnya.

Contoh

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

Jenis untuk penunjuk, dan const penunjuk, ke span elemen.

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

Contoh

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

Dapatkan iterator terbalik yang menunjuk ke elemen terakhir dari ini span.

constexpr reverse_iterator rbegin() const noexcept;

Nilai hasil

Iterator yang menunjuk ke awal terbalik span.

Contoh

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

Jenis untuk referensi, dan const referensi, ke span elemen.

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

Contoh

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

Dapatkan iterator akses acak yang menunjuk tepat di luar akhir terbalik span.

constexpr reverse_iterator rend() const noexcept;

Nilai hasil

Iterator terbalik ke tempat penampung mengikuti elemen terakhir dalam terbalik span; yaitu, tempat penampung sebelum elemen pertama dalam yang tidak terbalik span.

Keterangan

rend digunakan dengan terbalik span seperti span::end yang digunakan dengan span. Gunakan untuk menguji apakah iterator terbalik telah mencapai akhir span.

Nilai yang dikembalikan oleh rend tidak boleh didereferensikan.

Contoh

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

Jenis iterator terbalik untuk span.

using reverse_iterator = std::reverse_iterator<iterator>;

Contoh

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

Dapatkan jumlah elemen di span.

constexpr size_t size() const noexcept;

Nilai hasil

Jumlah elemen dalam span.

Contoh

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Dapatkan ukuran elemen dalam span byte.

constexpr size_type size_bytes() const noexcept;

Nilai hasil

Jumlah byte yang ditempati span semua elemen; yaitu, sizeof(element_type) dikalikan dengan jumlah elemen dalam span.

Contoh

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

Jenis yang tidak ditandatangani, cocok untuk menyimpan jumlah elemen dalam span.

using size_type = size_t;

Contoh

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

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

Parameter

arr
Buat span dari array.

count
Jumlah elemen yang akan berada di span.

first
Iterator ke elemen pertama dalam span.

last
Iterator untuk hanya melewati elemen terakhir di span.

N
Jumlah elemen yang akan berada di span.

other
Buat salinan ini span.

r
Buat span dari rentang R.

Keterangan

span Tidak membebaskan penyimpanan untuk item di span karena tidak memiliki penyimpanan objek di dalamnya.

Konstruktor	Deskripsi
`span()`	Buat kosong `span`. Hanya dipertimbangkan selama resolusi kelebihan beban saat parameter `Extent` templat adalah `0` atau `dynamic_extent`.
`span(It first, size_type count)`	Buat `span` dari elemen pertama `count` dari iterator `first`. Hanya dipertimbangkan selama resolusi kelebihan beban saat parameter `Extent` templat bukan `dynamic_extent`.
`span(It first, End last)`	Buat `span` dari elemen di iterator `first` hingga akhir `last` tercapai. Hanya dipertimbangkan selama resolusi kelebihan beban saat parameter `Extent` templat bukan `dynamic_extent`. `It` harus berupa `contiguous_iterator`.
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Buat `span` dari `N` elemen array yang ditentukan. Hanya dipertimbangkan selama resolusi kelebihan beban ketika parameter `Extent` templat atau `dynamic_extent` sama dengan `N`.
`span(R&& r)`	Buat `span` dari rentang. Hanya berpartisipasi dalam resolusi kelebihan beban jika parameter `Extent` templat bukan `dynamic_extent`.
`span(const span& other)`	Konstruktor salinan yang dihasilkan kompilator. Salinan pointer data yang dangkal aman karena `span` tidak mengalokasikan memori untuk menahan elemen.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Mengonversi konstruktor: membangun `span` dari konstruktor lain `span`. Hanya berpartisipasi dalam resolusi kelebihan beban jika parameter `Extent` templat adalah `dynamic_extent`, atau `N` `dynamic_extent` atau sama dengan `Extent`.

Contoh

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

Dapatkan subspan dari ini span.

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

Parameter

count
Jumlah elemen yang akan dimasukkan ke dalam subspan. Jika count adalah dynamic_extent (nilai default), maka subspan diambil dari offset ke akhir ini span.

offset
Lokasi dalam hal ini span untuk memulai subspan.

Nilai hasil

Mulai span dari offset dalam ini span. Berisi count elemen.

Keterangan

Versi templat dari fungsi ini tersedia yang memeriksa jumlah pada waktu kompilasi, yang mempertahankan informasi tentang span dengan mengembalikan span tingkat tetap.

Contoh

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

Jenis elemen dalam span, tanpa const atau volatile kualifikasi.

using value_type = std::remove_cv_t<T>;

Contoh

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

Panduan pengurangan

Panduan pengurangan berikut disediakan untuk 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>>>;

Lihat juga

<span>
Cara menggunakan pengurangan argumen templat kelas

Saran dan Komentar

Apakah halaman ini membantu?

Last updated on 2025-11-07

Bagikan melalui

span kelas (Pustaka Standar C++)

Sintaks

Parameter template

Anggota

Keterangan

Persyaratan

span::back

Nilai hasil

Contoh

span::begin

Nilai hasil

Contoh

span::data

Nilai hasil

Contoh

span::difference_type

Contoh

span::element_type

Keterangan

Contoh

span::empty

Nilai hasil

Contoh

span::end

Nilai hasil

Keterangan

Contoh

span::first

Parameter

Nilai hasil

Keterangan

Contoh

span::front

Nilai hasil

Contoh

span::iterator

Keterangan

Contoh

span::last

Parameter

Nilai hasil

Keterangan

Contoh

span::operator[]

Parameter

Nilai hasil

Contoh

span::operator=

Parameter

Nilai hasil

Keterangan

Contoh

span::pointer

Contoh

span::rbegin

Nilai hasil

Contoh

span::reference

Contoh

span::rend

Nilai hasil

Keterangan

Contoh

span::reverse_iterator

Contoh

span::size

Nilai hasil

Contoh

span::size_bytes

Nilai hasil

Contoh

span::size_type

Contoh

span::span

Parameter

Keterangan

Contoh

span::subspan

Parameter

`span` kelas (Pustaka Standar 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`