23 Containers library [containers]

23.7 Views [views]

23.7.2 Contiguous access [views.contiguous]

23.7.2.2 Class template span [views.span]

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

(3.1)
It satisfies contiguous_iterator .
(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]

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 2:
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(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]

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

(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]

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

Constraints: is_const_v<element_type> is true.

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

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:

(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]

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