`span` クラス (C++ 標準ライブラリ)

[アーティクル]
10/12/2023

連続した一連のオブジェクトの簡易表示を提供します。 spanは、メモリ内にバックツーバック配置されたオブジェクトを反復処理してインデックスを作成する安全な方法を提供します。組み込みの配列、 std::array、または std::vectorに格納されているオブジェクトなどです。

通常、ポインターとインデックスを使用してバックツーバックオブジェクトのシーケンスにアクセスする場合、span はより安全で軽量な代替手段となります。

span のサイズは、コンパイル時にテンプレート引数として指定するか、ランタイムに dynamic_extent を指定することによって設定できます。

構文

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

テンプレートパラメーター

T
span 内の要素の型。

Extent
コンパイル時に指定した場合の span 内の要素の数。それ以外の実行時に要素の数を指定する場合は、std::dynamic_extent。

演繹ガイド

メンバー

型定義	説明
`const_pointer`	`const` 要素へのポインターの型。
`const_reference`	`const` 要素への参照の型。
`difference_type`	2 つの要素間の距離を表す、符号付きの型です。
`element_type`	`span` 要素の型。
`iterator`	`span` の反復子の型。
`pointer`	要素へのポインターの型です。
`reference`	要素への参照の型です。
`reverse_iterator`	`span` の反転反復子の型。
`size_type`	`span` 内の 2 つの要素間の符号なし距離の結果の型。
`value_type`	要素の型 (`const` または `volatile` の修飾なし)。
コンストラクター	説明
`span`	`span` を構築します。
反復子のサポート	説明
`begin`	`span` 内の最初の要素を指す反復子を取得します。
`end`	`span` の末尾を指す反復子を取得します。
`rbegin`	`span` の最後の要素、つまり反転 `span` の開始部分を指す反転反復子を取得します。
`rend`	`span` の先頭、つまり反転 `span` の最後を指す反転反復子を取得します。
Access 要素	説明
`back`	`span` 内の最後の要素を取得します。
`data`	`span` 内の最初の要素のアドレスを取得します。
`front`	`span` 内の最初の要素を取得します。
`operator[]`	指定した位置にある要素にアクセスします。
オブザーバー	説明
`empty`	`span` が空かどうかをテストします。
`size`	`span` 内の要素の数を取得します。
`size_bytes`	`span` のサイズをバイト単位で取得します。
サブビュー	説明
`first`	`span` の前から subspan を取得します。
`last`	`span` の後から subspan を取得します。
`subspan`	`span` 内の任意の場所から subspan を取得します。
オペレーター	説明
`span::operator=`	`span` を置き換えます。
`span::operator[]`	指定した位置にある要素を取得します。

解説

すべての span メンバー関数には、一定の時間計算量があります。

array または vector とは異なり、span は、その中の要素を "所有" しません。 span は、含まれる項目のストレージを所有していないため、それらのオブジェクトのストレージを解放しません。

要件

Header: <span> (C++20 以降)

名前空間: std

コンパイラオプション: /std:c++20 以降が必要です。

`span::back`

span 内の最後の要素を取得します。

constexpr reference back() const noexcept;

戻り値

span の最後の要素への参照。

例

#include <span>
#include <iostream>

using namespace std;

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

    cout << mySpan.back();
}

`span::begin`

span 内の最初の要素を指す反復子を取得します。

constexpr iterator begin() const noexcept;

戻り値

span 内の最初の要素を指す反復子。

例

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

span データの先頭を指すポインターを取得します。

constexpr pointer data() const noexcept;

戻り値

span に格納されている最初の項目へのポインター。

例

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

span 内の 2 つの要素間の要素の数。

using difference_type = std::ptrdiff_t;

例

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

span 内の要素の型。

using element_type = T;

解説

span が作成されると、テンプレートパラメーター T から型が取得されます。

例

#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 に要素が含まれているかどうか。

constexpr bool empty() const noexcept;

戻り値

this->size() == 0 の場合は true を返します。それ以外の場合は false。

例

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

span の末尾までの反復子を取得します。

constexpr iterator end() const noexcept;

戻り値

span の末尾の次の位置を指す反復子。

解説

end は、反復子が範囲の末尾を超えたかどうかをテストするために使用されます。

この反復子によって返された値を逆参照しないでください。これは、反復子が span 内の最後の要素を超えたかどうかを識別するために使用します。

例

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

`span::first`

この span の前から取得した subspan を取得します。

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

パラメーター

count
subspan に配置する、この span の先頭からの要素の数。
要素の数は、次に示すように、テンプレートまたは関数にパラメーターとして指定します。

戻り値

この span の先頭から count 個の要素を格納している span。

解説

コンパイル時に count を検証できる場合、また、固定エクステントの span を返して以降の span に関する情報を保持するために、この関数のテンプレートバージョンを使用します。

例

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

span 内の最初の要素を取得します。

constexpr reference front() const noexcept;

戻り値

span 内の最初の要素への参照。

例

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

span 要素に対する iterator の型。

using iterator = implementation-defined-iterator-type;

解説

この型は、span 内の要素に対する iterator として機能します。

例

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

この span の終了から取得した subspan を取得します。

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;

パラメーター

count
subspan に格納する、この span の終了位置の要素の数。この数値は、次に示すように、テンプレートまたは関数へのパラメーターとして指定できます。

戻り値

この span の最後 count 要素を格納している span。

解説

例

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

span 内の指定した位置にある要素を取得します。

constexpr reference operator[](size_type offset) const;

パラメーター

offset
アクセスする span 内の 0 から始まる要素。

戻り値

offset位置にある要素への参照。その位置が無効な場合、動作は定義されません。

例

#include <span>
#include <iostream>

using namespace std;

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

`span::operator=`

別の span をこの span に割り当てます。

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

パラメーター

other
この span に割り当てる span。

戻り値

*this

解説

割り当てでは、データポインターとサイズの簡易コピーが行われます。 span は、それに含まれる要素にメモリを割り当てないため、簡易コピーは安全です。

例

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

span 要素へのポインターと const ポインターの型。

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

例

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

この span の最後の要素を指す反転反復子を取得します。

constexpr reverse_iterator rbegin() const noexcept;

戻り値

反転した span の先頭を指す反復子。

例

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

span 要素への参照と const 参照の型。

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

例

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

反転した span の末尾の次の位置を指し示すランダムアクセス反復子を取得します。

constexpr reverse_iterator rend() const noexcept;

戻り値

反転した span 内の最後の要素、つまり、反転されていない span 内の最初の要素の次のプレースホルダーへの反転反復子。

解説

rend は、span::end が span で使用されるのと同様に、反転された span で使用されます。反転反復子がその span の末尾に達したかどうかをテストするために使用します。

rend によって返された値は逆参照しないでください。

例

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

span の反転反復子の型。

using reverse_iterator = std::reverse_iterator<iterator>;

例

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

span 内の要素の数を取得します。

constexpr size_t size() const noexcept;

戻り値

span にある要素の数。

例

#include <span>
#include <iostream>

using namespace std;

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

`span::size_bytes`

span 内の要素のサイズをバイト単位で取得します。

constexpr size_type size_bytes() const noexcept;

戻り値

span 内のすべての要素が占有するバイト数。これは、sizeof(element_type) と span 内の要素の数を乗算した値です。

例

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

span 内の要素の数を格納するのに適した符号なしの型。

using size_type = size_t;

例

#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 コンストラクター。

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

パラメーター

arr
配列から span を構築します。

count
span に含まれる要素の数。

first
span 内の最初の要素への反復子。

last
span の最後の要素の次を指す反復子。

N
span に含まれる要素の数。

other
この span のコピーを作成します。

r
範囲 R から span を構築します。

解説

span は、span 内のオブジェクトのストレージを所有しないため、項目のストレージを解放しません。

Constructor	説明
`span()`	空の `span` を構築します。テンプレートパラメーター `Extent` が `0` または `dynamic_extent` の場合は、オーバーロードの解決中にのみ考慮します。
`span(It first, size_type count)`	反復子 `first` から最初の `count` 要素から `span` を構築します。テンプレートパラメーター `Extent` が `dynamic_extent` でない場合は、オーバーロードの解決中にのみ考慮されます。
`span(It first, End last)`	末尾の `last` に到達するまで、反復子 `first` 内の要素から `span` を構築します。テンプレートパラメーター `Extent` が `dynamic_extent` でない場合は、オーバーロードの解決中にのみ考慮されます。 `It` は `contiguous_iterator` である必要があります。
`span(array<T, N>& arr) noexcept;` `span(const array<T, N>& arr) noexcept;` `span(type_identity_t<element_type> (&arr)[N]) noexcept;`	指定した配列の `N` 要素から `span` を構築します。テンプレートパラメーター `Extent` が `dynamic_extent` の場合、または `N` と等しい場合は、オーバーロードの解決中にのみ考慮します。
`span(R&& r)`	範囲から `span` を構築します。テンプレートパラメーター `Extent` が `dynamic_extent` ではない場合にのみ、オーバーロードの解決に参加します。
`span(const span& other)`	コンパイラによって生成されたコピーコンストラクター。 `span` が要素を保持するメモリを割り当てないので、データポインターの簡易コピーが安全です。
`span(const span<OtherElementType, OtherExtent>& s) noexcept;`	コンストラクターの変換: 別の `span` から `span` を構築します。テンプレートパラメーター `Extent` が `dynamic_extent` の場合、または `N` が `dynamic_extent` であるか、`Extent` と等しい場合にのみ、オーバーロードの解決に参加します。

例

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

この span の subspan を取得します。

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

パラメーター

count
subspan に含む要素の数。 count が dynamic_extent (既定値) の場合、subspan は、offset からこの span の末尾まで取得されます。

offset
subspan を開始するこの span 内の場所。

戻り値

この span. の offset で始まる span。 count 要素を格納します。

解説

コンパイル時にカウントをチェックするテンプレートバージョンのこの関数を使用できます。これにより、固定エクステントの span を返して span に関する情報が保持されます。

例

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

const または volatile の修飾のない、span 内の要素の型。

using value_type = std::remove_cv_t<T>;

例

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

演繹ガイド

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

次の方法で共有

span クラス (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` クラス (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`