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::array
veya 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_extent
ayarlanabilir.
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.
Ü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 span
alın.
constexpr reference back() const noexcept;
Dönüş değeri
içindeki span
son öğ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();
}
2
span::begin
içindeki ilk öğeye span
işaret eden bir yineleyici alın.
constexpr iterator begin() const noexcept;
Dönüş değeri
içindeki ilk öğeye span
iş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;
}
0
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;
}
0
span::difference_type
bir span
iç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;
}
3
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;
}
2
span::empty
öğesinin span
öğe içerip içermediği.
constexpr bool empty() const noexcept;
Dönüş değeri
ise this->size() == 0
dö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 span
bir yineleyici alın.
constexpr iterator end() const noexcept;
Dönüş değeri
sonunun span
hemen ö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 span
alı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 span
alır.
constexpr reference front() const noexcept;
Dönüş değeri
içindeki span
ilk öğ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;
}
0
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
span
gö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;
}
012
span::last
Bu span
bö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];
}
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;
}
}
012
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;
}
90
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;
}
}
210
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;
}
91
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ş span
iç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 span
ile kullanılır. Ters yineleyicinin sonuna span
ulaşı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 span
ters 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;
}
210
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();
}
3
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 span
sayı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)
}
12
span::size_type
öğe sayısını bir içinde depolamak için uygun, imzasız bir span
tü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;
}
3
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 span
olacak öğe sayısı.
first
içindeki ilk öğeye span
yineleyici.
last
içindeki son öğeyi span
geçmek için yineleyici.
N
içinde span
olacak öğelerin sayısı.
other
Bunun span
bir kopyasını yapın.
r
aralığından R
bir 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 span
bir 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 span
iç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 span
tü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;
}
2
Kesinti kılavuzları
için span
aş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.
Geri Bildirim
https://aka.ms/ContentUserFeedback.
Çok yakında: 2024 boyunca, içerik için geri bildirim mekanizması olarak GitHub Sorunları’nı kullanımdan kaldıracak ve yeni bir geri bildirim sistemiyle değiştireceğiz. Daha fazla bilgi için bkz.Gönderin ve geri bildirimi görüntüleyin