[views.contiguous] (original) (raw)

23.7.2.2 Class template span [views.span]

23.7.2.2.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: 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; 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;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;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;constexpr size_type size() const noexcept;constexpr size_type size_bytes() const noexcept;constexpr bool empty() const noexcept;constexpr reference operator[](size_type idx) const;constexpr reference at(size_type idx) const; constexpr reference front() const;constexpr reference back() const;constexpr pointer data() const noexcept;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_; size_type size_; };template<class It, class EndOrSize> span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>,maybe-static-ext<EndOrSize>>;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.

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.

23.7.2.2.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>>.

• 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_]

Preconditions:

• [first, first + count) is a valid range.

Hardened preconditions: If extent is not equal to dynamic_extent, then count == extent is true.

Effects: Initializes data_ with to_address(first) and_size__ with count.

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

• 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_]
• is_convertible_v<End, size_t> is false.

Preconditions:

• [first, last) is a valid range.

Hardened preconditions: If extent is not equal to dynamic_extent, then (last - first) == extent is true.

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(std​::​data(arr))>.

• extent == dynamic_extent || N == extent is true, and
• 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_]

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

[Note 4:

type_identity_t affects class template argument deduction.

— _end note_]

Postconditions: size() == N && data() == std​::​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>>.

• Either R satisfies ranges​::​borrowed_range oris_const_v<element_type> is true.
• remove_cvref_t<R> is not a specialization of span.
• remove_cvref_t<R> is not a specialization of array.
• is_array_v<remove_cvref_t<R>> is false.
• 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_]

Preconditions:

• If is_const_v<element_type> is false,R models ranges​::​borrowed_range.

Hardened preconditions: If extent is not equal to dynamic_extent, then ranges​::​size(r) == extent is true.

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 explicit(extent != dynamic_extent) span(std::initializer_list<value_type> il);

Constraints: is_const_v<element_type> is true.

Hardened preconditions: If extent is not equal to dynamic_extent, then il.size() == extent is true.

Effects: Initializes data_ with il.begin() and_size__ with il.size().

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:

• extent == dynamic_extent || OtherExtent == dynamic_extent || extent == OtherExtent is true, and
• 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_]

Hardened preconditions: If extent is not equal to dynamic_extent, then s.size() == extent is true.

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().

23.7.2.2.3 Deduction guides [span.deduct]

template<class It, class EndOrSize> span(It, EndOrSize) -> span<remove_reference_t<iter_reference_t<It>>,[_maybe-static-ext_](#concept:maybe-static-ext "23.7.2.1 Header <span> synopsis [span.syn]")<EndOrSize>>;

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

23.7.2.2.4 Subviews [span.sub]

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

Mandates: Count <= Extent is true.

Hardened 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.

Hardened 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.

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

Hardened preconditions: count <= size() is true.

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

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

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

Hardened preconditions: offset <= size() && (count == dynamic_extent || count <= size() - offset) is true.

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

23.7.2.2.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);

constexpr bool empty() const noexcept;

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

23.7.2.2.6 Element access [span.elem]

constexpr reference operator[](size_type idx) const;

Hardened preconditions: idx < size() is true.

Returns: *(data() + idx).

constexpr reference at(size_type idx) const;

Returns: *(data() + idx).

Throws: out_of_range if idx >= size() is true.

constexpr reference front() const;

Hardened preconditions: empty() is false.

constexpr reference back() const;

Hardened preconditions: empty() is false.

Returns: *(data() + (size() - 1)).

constexpr pointer data() const noexcept;

23.7.2.2.7 Iterator support [span.iterators]

using iterator = _implementation-defined_;

All requirements on container iterators ([container.reqmts]) apply tospan​::​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());

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

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.