`span` class (C++ Standart Kitaplığı)

Bitişik bir nesne dizisi üzerinde basit bir görünüm sağlar. A span , bellekte arka arkaya yerleştirilmiş nesneleri yinelemek ve dizine almak için güvenli bir yol sağlar. Yerleşik dizide depolanan nesneler gibi, std::arrayveya std::vector.

Genellikle bir işaretçi ve dizin kullanarak arka arkaya nesneler dizisine erişirseniz, span daha güvenli ve basit bir alternatiftir.

bir span öğesinin boyutu, derleme zamanında şablon bağımsız değişkeni olarak belirtilerek veya çalışma zamanında belirtilerek dynamic_extentayarlanabilir.

Sözdizimi

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

Şablon parametreleri

T
içindeki spanöğelerin türü.

Extent
derleme zamanında belirtilirse içindeki span öğelerinin sayısı. Aksi takdirde std::dynamic_extent , öğe sayısı çalışma zamanında belirtilirse.

Kesinti kılavuzu

Üyeler

Tür Tanımları	Açıklama
`const_pointer`	Bir öğeye `const` işaretçi türü.
`const_reference`	Bir öğeye `const` başvuru türü.
`difference_type`	İki öğe arasındaki işaretli mesafenin türü.
`element_type`	Öğenin `span` türü.
`iterator`	için yineleyicinin `span`türü.
`pointer`	Bir öğe için bir işaretçi türü.
`reference`	Bir öğe için bir başvuru türü.
`reverse_iterator`	bir için `span`ters yineleyici türü.
`size_type`	içindeki iki öğe arasındaki işaretsiz uzaklık sonucunun `span`türü.
`value_type`	Veya `volatile` nitelemeleri olmayan `const` bir öğenin türü.
Oluşturucu	Açıklama
`span`	oluşturma `span`.
Yineleyici desteği	Açıklama
`begin`	içindeki ilk öğeye `span`işaret eden bir yineleyici alın.
`end`	öğesinin sonuna `span`işaret eden bir yineleyici alın.
`rbegin`	öğesinin son öğesine `span`, yani ters çevrilmiş `span`öğesinin başlangıcına işaret eden bir ters yineleyici alın.
`rend`	öğesinin önüne `span`, yani ters çevrilmiş `span`öğesinin sonuna işaret eden bir ters yineleyici alın.
Öğelere erişme	Açıklama
`back`	içindeki son öğeyi `span`alın.
`data`	içindeki ilk öğenin `span`adresini alın.
`front`	içindeki ilk öğeyi `span`alır.
`operator[]`	Belirtilen konumdaki bir öğeye erişin.
Gözlemci	Açıklama
`empty`	öğesinin `span` boş olup olmadığını test edin.
`size`	içindeki `span`öğe sayısını alır.
`size_bytes`	bayt cinsinden boyutunu `span` alır.
Alt Görünümler	Açıklama
`first`	öğesinin önünden `span`bir alt alan alın.
`last`	öğesinin arkasından `span`bir alt alan alın.
`subspan`	içinde herhangi bir yerden `span`bir alt alan alın.
İşleçler	Açıklama
`span::operator=`	değerini `span`değiştirin.
`span::operator[]`	Öğesini belirtilen konumda alın.

Açıklamalar

Tüm span üye işlevlerin zaman karmaşıklığı sabittir.

veya vector'nin aksinearray, içindeki span öğelere "sahip" değildir. içindeki span öğeler için depolama alanı boşaltmaz çünkü bu nesnelerin depolama alanı bu öğelere ait değildir.

Gereksinimler

Üst bilgi: <span> (C++20'den beri)

Ad alanı: std

Derleyici Seçeneği: /std:c++20 veya üzeri gereklidir.

`span::back`

içindeki son öğeyi spanalın.

constexpr reference back() const noexcept;

Dönüş değeri

içindeki spanson öğeye başvuru.

Örnek

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

içindeki ilk öğeye spanişaret eden bir yineleyici alın.

constexpr iterator begin() const noexcept;

Dönüş değeri

içindeki ilk öğeye spanişaret eden bir yineleyici.

Örnek

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

Verilerin başlangıcına span ilişkin bir işaretçi alın.

constexpr pointer data() const noexcept;

Dönüş değeri

içinde depolanan ilk öğenin işaretçisi span.

Örnek

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

bir spaniçindeki iki öğe arasındaki öğe sayısı.

using difference_type = std::ptrdiff_t;

Örnek

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

içindeki spanöğelerin türü.

using element_type = T;

Açıklamalar

Tür, bir span oluşturulduğunda şablon parametresinden T alınır.

Örnek

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

öğesinin span öğe içerip içermediği.

constexpr bool empty() const noexcept;

Dönüş değeri

ise this->size() == 0döndürürtrue. Aksi takdirde false.

Örnek

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

öğesinin sonuna spanbir yineleyici alın.

constexpr iterator end() const noexcept;

Dönüş değeri

sonunun spanhemen ötesine işaret eden bir yineleyici.

Açıklamalar

end bir yineleyicinin aralığının sonunu geçip geçmediğini test etmek için kullanılır.

Bu yineleyici tarafından döndürülen değerin başvurularını kaldırmayın. Yineleyicinin içindeki son öğenin spanötesine ulaşıp ulaşmadığını belirlemek için kullanın.

Örnek

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

`span::first`

Bunun önünden spanalınan bir alt alan alın.

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

Parametreler

count
Bunun önünden span alt bölmeye konulacak öğe sayısı.
Öğe sayısı, aşağıda gösterildiği gibi şablona veya işleve parametre olarak belirtilir.

Dönüş değeri

span Bu spanöğesinin önünden öğeleri içeren count bir.

Açıklamalar

Derleme zamanında doğrulamak count ve sabit bir kapsam döndürdüğünden span hakkındaki span bilgileri korumak için mümkün olduğunda bu işlevin şablon sürümünü kullanın.

Örnek

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

içindeki ilk öğeyi spanalır.

constexpr reference front() const noexcept;

Dönüş değeri

içindeki spanilk öğeye başvuru.

Örnek

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

Öğelerin üzerindeki span bir iterator türü.

using iterator = implementation-defined-iterator-type;

Açıklamalar

Bu tür, içindeki öğeler üzerinde bir iterator spangörevi görür.

Örnek

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

Bu spanbölümün sonundan alınan bir alt alan alın.

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;

Parametreler

count
Bunun sonundan span alt aralığına konulacak öğe sayısı. Sayı, aşağıda gösterildiği gibi şablona veya işleve parametre olarak belirtilebilir.

Dönüş değeri

span Bu spanöğesinden son count öğeleri içeren bir.

Açıklamalar

Derleme zamanında doğrulamak count ve sabit bir kapsam döndürdüğünden span hakkındaki span bilgileri korumak için mümkün olduğunda bu işlevin şablon sürümünü kullanın.

Örnek

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

öğesinde span belirtilen konumda alın.

constexpr reference operator[](size_type offset) const;

Parametreler

offset
erişecek öğesinde span sıfır tabanlı öğe.

Dönüş değeri

konumundaki offsetöğesine başvuru. Konum geçersizse, davranış tanımlanmamıştır.

Örnek

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

Buna bir tane daha span atayın.

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

Parametreler

other
span Buna atanacak olan.

Dönüş değeri

*this

Açıklamalar

Atama, veri işaretçisinin ve boyutun sığ bir kopyasını yapar. Sığ bir kopya, içerdiği öğeler için bellek ayırmadığından güvenlidir span .

Örnek

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

Bir öğeye yönelik işaretçi ve const işaretçi span türleri.

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

Örnek

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

Bu spanöğesinin son öğesine işaret eden bir ters yineleyici alın.

constexpr reverse_iterator rbegin() const noexcept;

Dönüş değeri

Ters çevrilmiş spanöğesinin başına işaret eden bir yineleyici.

Örnek

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

Bir öğeye başvuru ve const başvuru span türleri.

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

Örnek

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

Ters çevrilmiş spanöğesinin sonunun hemen ötesine işaret eden rastgele erişim yineleyicisi alın.

constexpr reverse_iterator rend() const noexcept;

Dönüş değeri

Ters çevrilmiş spaniçindeki son öğeyi izleyen yer tutucuya ters yineleyici; diğer bir ifadeyle, ters spançevrilmeyen içindeki ilk öğeden önceki yer tutucu.

Açıklamalar

rend, ile kullanıldığı gibi span::end ters çevrilmiş span bir spanile kullanılır. Ters yineleyicinin sonuna spanulaşıp ulaşmadığını test etmek için kullanın.

tarafından rend döndürülen değer başvurulmamalıdır.

Örnek

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

bir için spanters yineleyici türü.

using reverse_iterator = std::reverse_iterator<iterator>;

Örnek

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

içindeki spanöğe sayısını alır.

constexpr size_t size() const noexcept;

Dönüş değeri

içindeki spanöğe sayısı.

Örnek

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

Bayt cinsinden span öğelerin boyutunu alın.

constexpr size_type size_bytes() const noexcept;

Dönüş değeri

içindeki tüm öğelerin span kapladığı bayt sayısı; diğer bir ifadeyle sizeof(element_type) içindeki öğelerin spansayısıyla çarpılır.

Örnek

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

öğe sayısını bir içinde depolamak için uygun, imzasız bir spantür.

using size_type = size_t;

Örnek

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

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

Parametreler

arr
Diziden oluşturma span .

count
içinde spanolacak öğe sayısı.

first
içindeki ilk öğeye spanyineleyici.

last
içindeki son öğeyi spangeçmek için yineleyici.

N
içinde spanolacak öğelerin sayısı.

other
Bunun spanbir kopyasını yapın.

r
aralığından Rbir span oluşturur.

Açıklamalar

içindeki nesnelerin depolama alanı kendisinde olmadığından , span içindeki span öğeler için depolama alanı boşaltmaz.

Oluşturucu	Açıklama
`span()`	Boş `span`bir oluşturma. Yalnızca şablon parametresi veya `dynamic_extent`olduğunda aşırı yükleme çözümlemesi sırasında dikkate `Extent` `0` alınır.
`span(It first, size_type count)`	Yineleyiciden `first`ilk `count` öğelerden bir `span` oluşturma. Yalnızca şablon parametresi olmadığında `dynamic_extent`aşırı yükleme çözümlemesi sırasında dikkate `Extent` alınır.
`span(It first, End last)`	Sonuna `last` ulaşılana kadar yineleyicideki `first` öğelerden bir `span` oluşturur. Yalnızca şablon parametresi olmadığında `dynamic_extent`aşırı yükleme çözümlemesi sırasında dikkate `Extent` alınır. `It` bir `contiguous_iterator`olmalıdır.
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	Belirtilen dizinin öğelerinden `N` bir `span` oluşturma. Yalnızca şablon parametresi `Extent` `dynamic_extent` veya eşit olduğunda aşırı yükleme çözümlemesi sırasında dikkate `N`alınır.
`span(R&& r)`	Bir aralıktan oluşturma `span` . Yalnızca şablon parametresi `Extent` değilse `dynamic_extent`aşırı yükleme çözümlemeye katılır.
`span(const span& other)`	Derleyici tarafından oluşturulan kopya oluşturucu. Veri işaretçisinin sığ bir kopyası güvenlidir çünkü `span` öğeleri tutmak için belleği ayırmaz.
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	Oluşturucu dönüştürülüyor: başka `span`bir 'den bir `span` oluşturma. Yalnızca şablon parametresi `Extent` ise `dynamic_extent`veya `dynamic_extent` `N` veya eşitse aşırı yükleme çözümlemeye `Extent`katılır.

Örnek

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

Bunun spanbir alt alanını alın.

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

Parametreler

count
Alt bölmeye konulacak öğe sayısı. ise count dynamic_extent (varsayılan değer), alt aralığı bu spanöğesinin sonundan offset alınır.

offset
Alt aralığı başlatmak için bu span konumdaki konum.

Dönüş değeri

span Bu spaniçinde offset bir başlangıç. Öğeleri içerir count .

Açıklamalar

Bu işlevin derleme zamanında sayıyı denetleyen ve sabit bir kapsam döndürerek hakkındaki span bilgileri koruyan bir span şablon sürümü kullanılabilir.

Örnek

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

veya volatile nitelemeleri olmadan const içindeki öğesinin spantürü.

using value_type = std::remove_cv_t<T>;

Örnek

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

Kesinti kılavuzları

için spanaşağıdaki kesinti kılavuzları sağlanır.

// 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>>>;

Ayrıca bkz.

<span>
Sınıf şablonu bağımsız değişken kesintisini kullanma

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-07

Aracılığıyla paylaş

span class (C++ Standart Kitaplığı)

Sözdizimi

Şablon parametreleri

Üyeler

Açıklamalar

Gereksinimler

span::back

Dönüş değeri

Örnek

span::begin

Dönüş değeri

Örnek

span::data

Dönüş değeri

Örnek

span::difference_type

Örnek

span::element_type

Açıklamalar

Örnek

span::empty

Dönüş değeri

Örnek

span::end

Dönüş değeri

Açıklamalar

Örnek

span::first

Parametreler

Dönüş değeri

Açıklamalar

Örnek

span::front

Dönüş değeri

Örnek

span::iterator

Açıklamalar

Örnek

span::last

Parametreler

Dönüş değeri

Açıklamalar

Örnek

span::operator[]

Parametreler

Dönüş değeri

Örnek

span::operator=

Parametreler

Dönüş değeri

Açıklamalar

Örnek

span::pointer

Örnek

span::rbegin

Dönüş değeri

Örnek

span::reference

Örnek

span::rend

Dönüş değeri

Açıklamalar

Örnek

span::reverse_iterator

Örnek

span::size

Dönüş değeri

Örnek

span::size_bytes

Dönüş değeri

Örnek

span::size_type

Örnek

span::span

Parametreler

Açıklamalar

Örnek

span::subspan

Parametreler

`span` class (C++ Standart Kitaplığı)

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