24 Containers library [containers]

24.7 Views [views]

24.7.2 Contiguous access [views.contiguous]

24.7.2.1 Header <span> synopsis [span.syn]

🔗
#include <initializer_list> // see [initializer.list.syn] // mostly freestanding namespace std { // constants inline constexpr size_t dynamic_extent = numeric_limits<size_t>::max(); // [views.span], class template span template<class ElementType, size_t Extent = dynamic_extent> class span; // partially freestanding template<class ElementType, size_t Extent> constexpr bool ranges::enable_view<span<ElementType, Extent>> = true; template<class ElementType, size_t Extent> constexpr bool ranges::enable_borrowed_range<span<ElementType, Extent>> = true; // [span.objectrep], views of object representation template<class ElementType, size_t Extent> span<const byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent> as_bytes(span<ElementType, Extent> s) noexcept; template<class ElementType, size_t Extent> span<byte, Extent == dynamic_extent ? dynamic_extent : sizeof(ElementType) * Extent> as_writable_bytes(span<ElementType, Extent> s) noexcept; }

24.7.2.2 Class template span [views.span]

24.7.2.2.1 Overview [span.overview]

1
#
A span is a view over a contiguous sequence of objects, the storage of which is owned by some other object.
2
#
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 const_iterator = std::const_iterator<iterator>; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::const_iterator<reverse_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 explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il); constexpr span(const span& other) noexcept = default; template<class OtherElementType, size_t OtherExtent> constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept; 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 at(size_type idx) const; // freestanding-deleted 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 const_iterator cbegin() const noexcept { return begin(); } constexpr const_iterator cend() const noexcept { return end(); } constexpr reverse_iterator rbegin() const noexcept; constexpr reverse_iterator rend() const noexcept; constexpr const_reverse_iterator crbegin() const noexcept { return rbegin(); } constexpr const_reverse_iterator crend() const noexcept { return rend(); } 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>>>; }
3
#
span<ElementType, Extent> is a trivially copyable type ([basic.types.general]).
4
#
ElementType is required to be a complete object type that is not an abstract class type.
5
#
For a span s, any operation that invalidates a pointer in the range [s.data(), s.data() + s.size()) invalidates pointers, iterators, and references to elements of s.

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

🔗
constexpr span() noexcept;
1
#
Constraints: Extent == dynamic_extent || Extent == 0 is true.
2
#
Postconditions: size() == 0 && data() == nullptr.
🔗
template<class It> constexpr explicit(extent != dynamic_extent) span(It first, size_type count);
3
#
Constraints: Let U be remove_reference_t<iter_reference_t<It>>.
  • (3.1)
  • (3.2)
    is_convertible_v<U(*)[], element_type(*)[]> is true.
    [Note 1: 
    The intent is to allow only qualification conversions of the iterator reference type to element_type.
    — end note]
4
#
Preconditions:
5
#
Effects: Initializes data_ with to_address(first) and size_ with count.
6
#
Throws: Nothing.
🔗
template<class It, class End> constexpr explicit(extent != dynamic_extent) span(It first, End last);
7
#
Constraints: Let U be remove_reference_t<iter_reference_t<It>>.
  • (7.1)
    is_convertible_v<U(*)[], element_type(*)[]> is true.
    [Note 2: 
    The intent is to allow only qualification conversions of the iterator reference type to element_type.
    — end note]
  • (7.2)
  • (7.3)
    End satisfies sized_sentinel_for<It>.
  • (7.4)
    is_convertible_v<End, size_t> is false.
8
#
Preconditions:
9
#
Effects: Initializes data_ with to_address(first) and size_ with last - first.
10
#
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;
11
#
Constraints: Let U be remove_pointer_t<decltype(std​::​data(arr))>.
  • (11.1)
    extent == dynamic_extent || N == extent is true, and
  • (11.2)
    is_convertible_v<U(*)[], element_type(*)[]> is true.
    [Note 3: 
    The intent is to allow only qualification conversions of the array element type to element_type.
    — end note]
12
#
Effects: Constructs a span that is a view over the supplied array.
[Note 4: 
type_identity_t affects class template argument deduction.
— end note]
13
#
Postconditions: size() == N && data() == std​::​data(arr) is true.
🔗
template<class R> constexpr explicit(extent != dynamic_extent) span(R&& r);
14
#
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 5: 
    The intent is to allow only qualification conversions of the range reference type to element_type.
    — end note]
15
#
Preconditions:
16
#
Effects: Initializes data_ with ranges​::​data(r) and size_ with ranges​::​size(r).
17
#
Throws: What and when ranges​::​data(r) and ranges​::​size(r) throw.
🔗
constexpr explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il);
18
#
Constraints: is_const_v<element_type> is true.
19
#
Preconditions: If extent is not equal to dynamic_extent, then il.size() is equal to extent.
20
#
Effects: Initializes data_ with il.begin() and size_ with il.size().
🔗
constexpr span(const span& other) noexcept = default;
21
#
Postconditions: other.size() == size() && other.data() == data().
🔗
template<class OtherElementType, size_t OtherExtent> constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
22
#
Constraints:
  • (22.1)
    extent == dynamic_extent || OtherExtent == dynamic_extent || extent == OtherExtent is true, and
  • (22.2)
    is_convertible_v<OtherElementType(*)[], element_type(*)[]> is true.
    [Note 6: 
    The intent is to allow only qualification conversions of the OtherElementType to element_type.
    — end note]
23
#
Preconditions: If extent is not equal to dynamic_extent, then s.size() is equal to extent.
24
#
Effects: Constructs a span that is a view over the range [s.data(), s.data() + s.size()).
25
#
Postconditions: size() == s.size() && data() == s.data().
26
#
Remarks: The expression inside explicit is equivalent to: extent != dynamic_extent && OtherExtent == dynamic_extent
🔗
constexpr span& operator=(const span& other) noexcept = default;
27
#
Postconditions: size() == other.size() && data() == other.data().

24.7.2.2.3 Deduction guides [span.deduct]

🔗
template<class It, class EndOrSize> span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>>;
1
#
Constraints: It satisfies contiguous_iterator.
🔗
template<class R> span(R&&) -> span<remove_reference_t<ranges::range_reference_t<R>>>;
2
#
Constraints: R satisfies ranges​::​contiguous_range.

24.7.2.2.4 Subviews [span.sub]

🔗
template<size_t Count> constexpr span<element_type, Count> first() const;
1
#
Mandates: Count <= Extent is true.
2
#
Preconditions: Count <= size() is true.
3
#
Effects: Equivalent to: return R{data(), Count}; where R is the return type.
🔗
template<size_t Count> constexpr span<element_type, Count> last() const;
4
#
Mandates: Count <= Extent is true.
5
#
Preconditions: Count <= size() is true.
6
#
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;
7
#
Mandates: Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset) is true.
8
#
Preconditions: Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset) is true.
9
#
Effects: Equivalent to: return span<ElementType, see below>( data() + Offset, Count != dynamic_extent ? Count : size() - Offset);
10
#
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;
11
#
Preconditions: count <= size() is true.
12
#
Effects: Equivalent to: return {data(), count};
🔗
constexpr span<element_type, dynamic_extent> last(size_type count) const;
13
#
Preconditions: count <= size() is true.
14
#
Effects: Equivalent to: return {data() + (size() - count), count};
🔗
constexpr span<element_type, dynamic_extent> subspan( size_type offset, size_type count = dynamic_extent) const;
15
#
Preconditions: offset <= size() && (count == dynamic_extent || count <= size() - offset) is true.
16
#
Effects: Equivalent to: return {data() + offset, count == dynamic_extent ? size() - offset : count};

24.7.2.2.5 Observers [span.obs]

🔗
constexpr size_type size() const noexcept;
1
#
Effects: Equivalent to: return size_;
🔗
constexpr size_type size_bytes() const noexcept;
2
#
Effects: Equivalent to: return size() * sizeof(element_type);
🔗
[[nodiscard]] constexpr bool empty() const noexcept;
3
#
Effects: Equivalent to: return size() == 0;

24.7.2.2.6 Element access [span.elem]

🔗
constexpr reference operator[](size_type idx) const;
1
#
Preconditions: idx < size() is true.
2
#
Effects: Equivalent to: return *(data() + idx);
🔗
constexpr reference at(size_type idx) const;
3
#
Returns: *(data() + idx).
4
#
Throws: out_of_range if idx >= size() is true.
🔗
constexpr reference front() const;
5
#
Preconditions: empty() is false.
6
#
Effects: Equivalent to: return *data();
🔗
constexpr reference back() const;
7
#
Preconditions: empty() is false.
8
#
Effects: Equivalent to: return *(data() + (size() - 1));
🔗
constexpr pointer data() const noexcept;
9
#
Effects: Equivalent to: return data_;

24.7.2.2.7 Iterator support [span.iterators]

🔗
using iterator = implementation-defined;
1
#
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]), whose value type is value_type and whose reference type is reference.
2
#
All requirements on container iterators ([container.reqmts]) apply to span​::​iterator as well.
🔗
constexpr iterator begin() const noexcept;
3
#
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;
4
#
Returns: An iterator which is the past-the-end value.
🔗
constexpr reverse_iterator rbegin() const noexcept;
5
#
Effects: Equivalent to: return reverse_iterator(end());
🔗
constexpr reverse_iterator rend() const noexcept;
6
#
Effects: Equivalent to: return reverse_iterator(begin());

24.7.2.3 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;
1
#
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;
2
#
Constraints: is_const_v<ElementType> is false.
3
#
Effects: Equivalent to: return R{reinterpret_cast<byte*>(s.data()), s.size_bytes()}; where R is the return type.