std::span<T,Extent>::subspan

template< std::size_t Offset,
          std::size_t Count = std::dynamic_extent >
constexpr std::span<element_type, /* see below */>
    subspan() const;

(1)

(since C++20)

constexpr std::span<element_type, std::dynamic_extent>
    subspan( size_type offset,
             size_type count = std::dynamic_extent ) const;

(2)

(since C++20)

Obtains a subview over some consecutive elements of this span, the elements to be included are determined by an element count and an offset.

1) The element count and offset are provided as template arguments, and the subview has a dynamic extent only if both Count and Extent are std::dynamic_extent.

If Count is std::dynamic_extent, the subview contains all elements starting from the Offset^th.
Otherwise, the subview contains Count elements starting from the Offset^th.

Denote the second template argument of the return type as FinalExtent, it is defined as

Count != std::dynamic_extent
    ? Count
    : (Extent != std::dynamic_extent
       ? Extent - Offset
       : std::dynamic_extent)

If Offset <= Extent && (Count == std::dynamic_extent || Count <= Extent - Offset) is false, the program is ill-formed.

If Offset <= size() && (Count == std::dynamic_extent || Count <= size() - Offset) is false, the behavior is undefined.

(until C++26)

If Offset <= size() && (Count == std::dynamic_extent || Count <= size() - Offset) is false:

If the implementation is hardened, a contract violation occurs.
If the implementation is not hardened, the behavior is undefined.

(since C++26)

2) The element count and offset are provided as function arguments, and the subview always has a dynamic extent.

If count is std::dynamic_extent, the subview contains all elements starting from the offset^th.
Otherwise, the subview contains count elements starting from the offset^th.

If offset <= size() && (count == std::dynamic_extent || count <= size() - offset) is false, the behavior is undefined.

(until C++26)

If offset <= size() && (count == std::dynamic_extent || count <= size() - offset) is false:

If the implementation is hardened, a contract violation occurs.
If the implementation is not hardened, the behavior is undefined.

(since C++26)

Return value

1) Returns

std::span<element_type, FinalExtent>
    (data() + Offset, Count != std::dynamic_extent ? Count : size() - Offset))

2) Returns

std::span<element_type, std::dynamic_extent>
    (data() + offset, count != std::dynamic_extent ? count : size() - offset))

Example

#include <algorithm>
#include <cstdio>
#include <numeric>
#include <ranges>
#include <span>

void put_char(char c)
{
    std::putchar(c);
}

void display(std::span<const char> abc)
{
    const auto columns{20U};
    const auto rows{abc.size() - columns + 1};

    for (auto offset{0U}; offset < rows; ++offset)
    {
        std::ranges::for_each(abc.subspan(offset, columns), put_char);
        std::puts("");
    }
}

int main()
{
    char abc[26];
    std::ranges::iota(abc, 'A');
    display(abc);
}

Output:

ABCDEFGHIJKLMNOPQRST
BCDEFGHIJKLMNOPQRSTU
CDEFGHIJKLMNOPQRSTUV
DEFGHIJKLMNOPQRSTUVW
EFGHIJKLMNOPQRSTUVWX
FGHIJKLMNOPQRSTUVWXY
GHIJKLMNOPQRSTUVWXYZ

first	obtains a subspan consisting of the first `N` elements of the sequence (public member function)
last	obtains a subspan consisting of the last `N` elements of the sequence (public member function)

std::span<T,Extent>::subspan

Return value

Example

See also