22 Containers library [containers]

22.7 Views [views]

22.7.3 Class template span [views.span]

22.7.3.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)
    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
    ]
4
#
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.
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
    :
    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.
8
#
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>.
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(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
    ]
12
#
Effects: Constructs a span that is a view over the supplied array.
[Note
:
type_­identity_­t affects class template argument deduction.
— end note
]
13
#
Postconditions: size() == N && data() == 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
    :
    The intent is to allow only qualification conversions of the range reference type to element_­type.
    — end note
    ]
15
#
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.
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 span(const span& other) noexcept = default;
18
#
Postconditions: other.size() == size() && other.data() == data().
🔗
template<class OtherElementType, size_t OtherExtent> constexpr explicit(see below) span(const span<OtherElementType, OtherExtent>& s) noexcept;
19
#
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
    ]
20
#
Preconditions: If extent is not equal to dynamic_­extent, then s.size() is equal to extent.
21
#
Effects: Constructs a span that is a view over the range [s.data(), s.data() + s.size()).
22
#
Postconditions: size() == s.size() && data() == s.data().
23
#
Remarks: The expression inside explicit is equivalent to: 
extent != dynamic_extent && OtherExtent == dynamic_extent
🔗
constexpr span& operator=(const span& other) noexcept = default;
24
#
Postconditions: size() == other.size() && data() == other.data().