Namespaces
Variants

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

From cppreference.net
C++
Containers library
std::span
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 Offset 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. Moreover, if the contract-violation handler returns under “observe” evaluation semantic, the behavior is undefined.
  • 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. Moreover, if the contract-violation handler returns under “observe” evaluation semantic, the behavior is undefined.
  • If the implementation is not hardened, the behavior is undefined.
(since C++26)

Return value

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

Example

Run this code 
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <ranges>
#include <span>
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), std::putchar);
        std::puts("");
    }
}
int main()
{
    char abc[26];
    std::ranges::iota(abc, 'A');
    display(abc);
}

Output: 

ABCDEFGHIJKLMNOPQRST
BCDEFGHIJKLMNOPQRSTU
CDEFGHIJKLMNOPQRSTUV
DEFGHIJKLMNOPQRSTUVW
EFGHIJKLMNOPQRSTUVWX
FGHIJKLMNOPQRSTUVWXY
GHIJKLMNOPQRSTUVWXYZ

See also

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