22 Containers library [containers]

22.7 Views [views]

22.7.3 Class template span [views.span]

22.7.3.1 Overview [span.overview]

A span is a view over a contiguous sequence of objects, the storage of which is owned by some other object.

All member functions of span have constant time complexity.

namespace std {
  template<class ElementType, size_t Extent = dynamic_extent>
  class span {
  public:
    // constants and types
    using element_type = ElementType;
    using value_type = remove_cv_t<ElementType>;
    using size_type = size_t;
    using difference_type = ptrdiff_t;
    using pointer = element_type*;
    using const_pointer = const element_type*;
    using reference = element_type&;
    using const_reference = const element_type&;
    using iterator = implementation-defined;        // see [span.iterators]
    using reverse_iterator = std::reverse_iterator<iterator>;
    static constexpr size_type extent = Extent;

    // [span.cons], constructors, copy, and assignment
    constexpr span() noexcept;
    template<class It>
      constexpr explicit(extent != dynamic_extent) span(It first, size_type count);
    template<class It, class End>
      constexpr explicit(extent != dynamic_extent) span(It first, End last);
    template<size_t N>
      constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
    template<class T, size_t N>
      constexpr span(array<T, N>& arr) noexcept;
    template<class T, size_t N>
      constexpr span(const array<T, N>& arr) noexcept;
    template<class R>
      constexpr explicit(extent != dynamic_extent) span(R&& r);
    constexpr span(const span& other) noexcept = default;
    template<class OtherElementType, size_t OtherExtent>
      constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;

    ~span() noexcept = default;

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

    // [span.sub], subviews
    template<size_t Count>
      constexpr span<element_type, Count> first() const;
    template<size_t Count>
      constexpr span<element_type, Count> last() const;
    template<size_t Offset, size_t Count = dynamic_extent>
      constexpr span<element_type, see below> subspan() const;

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

    // [span.obs], observers
    constexpr size_type size() const noexcept;
    constexpr size_type size_bytes() const noexcept;
    [[nodiscard]] constexpr bool empty() const noexcept;

    // [span.elem], element access
    constexpr reference operator[](size_type idx) const;
    constexpr reference front() const;
    constexpr reference back() const;
    constexpr pointer data() const noexcept;

    // [span.iterators], iterator support
    constexpr iterator begin() const noexcept;
    constexpr iterator end() const noexcept;
    constexpr reverse_iterator rbegin() const noexcept;
    constexpr reverse_iterator rend() const noexcept;

  private:
    pointer data_;              // exposition only
    size_type size_;            // exposition only
  };

  template<class It, class EndOrSize>
    span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
  template<class T, size_t N>
    span(T (&)[N]) -> span<T, N>;
  template<class T, size_t N>
    span(array<T, N>&) -> span<T, N>;
  template<class T, size_t N>
    span(const array<T, N>&) -> span<const T, N>;
  template<class R>
    span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
}

ElementType is required to be a complete object type that is not an abstract class type.

22.7.3.2 Constructors, copy, and assignment [span.cons]

🔗

constexpr span() noexcept;

Constraints: Extent == dynamic_extent || Extent == 0 is true.

Postconditions: size() == 0 && data() == nullptr.

🔗

template<class It>
  constexpr explicit(extent != dynamic_extent) span(It first, size_type count);

Constraints: Let U be remove_reference_t<iter_reference_t<It>>.

(3.1)
It satisfies contiguous_iterator.
(3.2)
is_convertible_v<U(*)[], element_type(*)[]> is true.

[Note
:
The intent is to allow only qualification conversions of the iterator reference type to element_type.
— end note
]

Preconditions:

(4.1)
[first, first + count) is a valid range.
(4.2)
It models contiguous_iterator.
(4.3)
If extent is not equal to dynamic_extent, then count is equal to extent.

Effects: Initializes data_ with to_address(first) and size_ with count.

Throws: Nothing.

🔗

template<class It, class End>
  constexpr explicit(extent != dynamic_extent) span(It first, End last);

Constraints: Let U be remove_reference_t<iter_reference_t<It>>.

(7.1)
is_convertible_v<U(*)[], element_type(*)[]> is true.

[Note
:
The intent is to allow only qualification conversions of the iterator reference type to element_type.
— end note
]
(7.2)
It satisfies contiguous_iterator.
(7.3)
End satisfies sized_sentinel_for<It>.
(7.4)
is_convertible_v<End, size_t> is false.

Preconditions:

(8.1)
If extent is not equal to dynamic_extent, then last - first is equal to extent.
(8.2)
[first, last) is a valid range.
(8.3)
It models contiguous_iterator.
(8.4)
End models sized_sentinel_for<It>.

Effects: Initializes data_ with to_address(first) and size_ with last - first.

Throws: When and what last - first throws.

🔗

template<size_t N> constexpr span(type_identity_t<element_type> (&arr)[N]) noexcept;
template<class T, size_t N> constexpr span(array<T, N>& arr) noexcept;
template<class T, size_t N> constexpr span(const array<T, N>& arr) noexcept;

Constraints: Let U be remove_pointer_t<decltype(data(arr))>.

(11.1)
extent == dynamic_extent || N == extent is true, and
(11.2)
is_convertible_v<U(*)[], element_type(*)[]> is true.

[Note
:
The intent is to allow only qualification conversions of the array element type to element_type.
— end note
]

Effects: Constructs a span that is a view over the supplied array.

[Note

type_identity_t affects class template argument deduction.

— end note

]

Postconditions: size() == N && data() == data(arr) is true.

🔗

template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);

Constraints: Let U be remove_reference_t<ranges::range_reference_t<R>>.

(14.1)
R satisfies ranges::contiguous_range and ranges::sized_range.
(14.2)
Either R satisfies ranges::borrowed_range or is_const_v<element_type> is true.
(14.3)
remove_cvref_t<R> is not a specialization of span.
(14.4)
remove_cvref_t<R> is not a specialization of array.
(14.5)
is_array_v<remove_cvref_t<R>> is false.
(14.6)
is_convertible_v<U(*)[], element_type(*)[]> is true.

[Note
:
The intent is to allow only qualification conversions of the range reference type to element_type.
— end note
]

Preconditions:

(15.1)
If extent is not equal to dynamic_extent, then ranges::size(r) is equal to extent.
(15.2)
R models ranges::contiguous_range and ranges::sized_range.
(15.3)
If is_const_v<element_type> is false, R models ranges::borrowed_range.

Effects: Initializes data_ with ranges::data(r) and size_ with ranges::size(r).

Throws: What and when ranges::data(r) and ranges::size(r) throw.

🔗

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

Postconditions: other.size() == size() && other.data() == data().

🔗

template<class OtherElementType, size_t OtherExtent>
  constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;

Constraints:

(19.1)
extent == dynamic_extent || OtherExtent == dynamic_extent || extent == OtherExtent is true, and
(19.2)
is_convertible_v<OtherElementType(*)[], element_type(*)[]> is true.
[Note
: The intent is to allow only qualification conversions of the OtherElementType to element_type. — end note
]

Preconditions: If extent is not equal to dynamic_extent, then s.size() is equal to extent.

Effects: Constructs a span that is a view over the range [s.data(), s.data() + s.size()).

Postconditions: size() == s.size() && data() == s.data().

Remarks: The expression inside explicit is equivalent to:

extent != dynamic_extent && OtherExtent == dynamic_extent

🔗

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

Postconditions: size() == other.size() && data() == other.data().

22.7.3.3 Deduction guides [span.deduct]

🔗

template<class It, class EndOrSize>
  span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;

Constraints: It satisfies contiguous_iterator.

🔗

template<class R>
  span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;

Constraints: R satisfies ranges::contiguous_range.

22.7.3.4 Subviews [span.sub]

🔗

template<size_t Count> constexpr span<element_type, Count> first() const;

Mandates: Count <= Extent is true.

Preconditions: Count <= size() is true.

Effects: Equivalent to: return R{data(), Count}; where R is the return type.

🔗

template<size_t Count> constexpr span<element_type, Count> last() const;

Mandates: Count <= Extent is true.

Preconditions: Count <= size() is true.

Effects: Equivalent to: return R{data() + (size() - Count), Count}; where R is the return type.

🔗

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

Mandates:

Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset)

is true.

Preconditions:

Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset)

is true.

Effects: Equivalent to:

return span<ElementType, see below>(
  data() + Offset, Count != dynamic_extent ? Count : size() - Offset);

Remarks: The second template argument of the returned span type is:

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

🔗

constexpr span<element_type, dynamic_extent> first(size_type count) const;

Preconditions: count <= size() is true.

Effects: Equivalent to: return {data(), count};

🔗

constexpr span<element_type, dynamic_extent> last(size_type count) const;

Preconditions: count <= size() is true.

Effects: Equivalent to: return {data() + (size() - count), count};

🔗

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

Preconditions:

offset <= size() && (count == dynamic_extent || count <= size() - offset)

is true.

Effects: Equivalent to:

return {data() + offset, count == dynamic_extent ? size() - offset : count};

22.7.3.5 Observers [span.obs]

🔗

constexpr size_type size() const noexcept;

Effects: Equivalent to: return size_;

🔗

constexpr size_type size_bytes() const noexcept;

Effects: Equivalent to: return size() * sizeof(element_type);

🔗

[[nodiscard]] constexpr bool empty() const noexcept;

Effects: Equivalent to: return size() == 0;

22.7.3.6 Element access [span.elem]

🔗

constexpr reference operator[](size_type idx) const;

Preconditions: idx < size() is true.

Effects: Equivalent to: return *(data() + idx);

🔗

constexpr reference front() const;

Preconditions: empty() is false.

Effects: Equivalent to: return *data();

🔗

constexpr reference back() const;

Preconditions: empty() is false.

Effects: Equivalent to: return *(data() + (size() - 1));

🔗

constexpr pointer data() const noexcept;

Effects: Equivalent to: return data_;

22.7.3.7 Iterator support [span.iterators]

🔗

using iterator = implementation-defined;

The type models contiguous_iterator ([iterator.concept.contiguous]), meets the Cpp17RandomAccessIterator requirements ([random.access.iterators]), and meets the requirements for constexpr iterators ([iterator.requirements.general]).

All requirements on container iterators ([container.requirements]) apply to span::iterator as well.

🔗

constexpr iterator begin() const noexcept;

Returns: An iterator referring to the first element in the span.

If empty() is true, then it returns the same value as end().

🔗

constexpr iterator end() const noexcept;

Returns: An iterator which is the past-the-end value.

🔗

constexpr reverse_iterator rbegin() const noexcept;

Effects: Equivalent to: return reverse_iterator(end());

🔗

constexpr reverse_iterator rend() const noexcept;

Effects: Equivalent to: return reverse_iterator(begin());

22.7.3.8 Views of object representation [span.objectrep]

🔗

template<class ElementType, size_t Extent>
  span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
    as_bytes(span<ElementType, Extent> s) noexcept;

Effects: Equivalent to: return R{reinterpret_cast<const byte*>(s.data()), s.size_bytes()}; where R is the return type.

🔗

template<class ElementType, size_t Extent>
  span<byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent>
    as_writable_bytes(span<ElementType, Extent> s) noexcept;

Constraints: is_const_v<ElementType> is false.

Effects: Equivalent to: return R{reinterpret_cast<byte*>(s.data()), s.size_bytes()}; where R is the return type.