[mdspan.extents.cons]

🔗

template<class OtherIndexType, size_t.. OtherExtents>
  constexpr explicit(see below)
    extents(const extents<OtherIndexType, OtherExtents..>& other) noexcept;

Preconditions:

(2.1)
other.extent(r) equals ${E r for each r for which {E r is a static extent, and}_{r is a static extent, and}}_{r for each r for which {E r is a static extent, and}_{r is a static extent, and}}$
(2.2)
either
- (2.2.1)
  sizeof.(OtherExtents) is zero, or
- (2.2.2)
  other.extent(r) is representable as a value of type index_type for every rank index r of other.

Remarks: The expression inside explicit is equivalent to: ((Extents != dynamic_extent) && (OtherExtents == dynamic_extent)) || .. ) || (numeric_limits<index_type>::max() < numeric_limits<OtherIndexType>::max()

🔗

template<class. OtherIndexTypes>
  constexpr explicit extents(OtherIndexTypes.. exts) noexcept;

Let N be sizeof.(OtherIndexTypes), and let exts_arr be array<index_type, N>{static_cast<
index_type>(std::move(exts)).}.

Constraints:

(6.1)
(is_convertible_v<OtherIndexTypes, index_type> && ..) is true,
(6.2)
(is_nothrow_constructible_v<index_type, OtherIndexTypes> && ..) is true, and
(6.3)
N == rank_dynamic() || N == rank() is true.
[Note 1:
One can construct extents from just dynamic extents, which are all the values getting stored, or from all the extents with a precondition.
— end note]

Preconditions:

(7.1)
If N != rank_dynamic() is true, exts_arr[r] equals ${E r for each r for which {E r is a static extent, and}_{r is a static extent, and}}_{r for each r for which {E r is a static extent, and}_{r is a static extent, and}}$
(7.2)
either
- (7.2.1)
  sizeof.(exts) == 0 is true, or
- (7.2.2)
  each element of exts is representable as a nonnegative value of type index_type.

Postconditions: *this == extents(exts_arr) is true.

🔗

template<class OtherIndexType, size_t N>
  constexpr explicit(N != rank_dynamic()
    extents(span<OtherIndexType, N> exts) noexcept;
template<class OtherIndexType, size_t N>
  constexpr explicit(N != rank_dynamic()
    extents(const array<OtherIndexType, N>& exts) noexcept;

Preconditions:

(10.1)
If N != rank_dynamic() is true, exts[r] equals ${E r for each r for which {E r is a static extent, and}_{r is a static extent, and}}_{r for each r for which {E r is a static extent, and}_{r is a static extent, and}}$
(10.2)
either
- (10.2.1)
  N is zero, or
- (10.2.2)
  exts[r] is representable as a nonnegative value of type index_type for every rank index r.

Effects:

(11.1)
If N equals rank_dynamic(), for all d in the range [0, rank_dynamic()), direct-non-list-initializes dynamic-extents[d] with as_const(exts[d]).
(11.2)
Otherwise, for all d in the range [0, rank_dynamic()), direct-non-list-initializes dynamic-extents[d] with as_const(exts[dynamic-index-inv(d)]).

🔗

template<class. Integrals>
  explicit extents(Integrals..) -> see below;

Remarks: The deduced type is extents<size_t, maybe-static-ext<Integrals>.>.

23 Containers library [containers]

23.7 Views [views]

23.7.3 Multidimensional access [views.multidim]

23.7.3.3 Class template extents [mdspan.extents]

23.7.3.3.3 Constructors [mdspan.extents.cons]